Especially since good old FORTRAN has
made a new appearance:

TIOBE Index for May 2024
I have received a lot of questions why Fortran entered the top 10
again after more than 20 years. The TIOBE index just publishes
what has been measured.
https://www.tiobe.com/tiobe-index/

Why Fortran is back in TIOBE’s top 10
First, Fortran is especially good at numerical analysis and
computational mathematics. Numerical and mathematical
computing is growing because interest in artificial intelligence
is growing, Jansen told TechRepublic in an email. https://www.techrepublic.com/article/tiobe-index-may-2024/

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Anybody tried to combine raylib with SWI-Prolog.
Like programming snake or something? Like here:

Raylib bindings to Scryer Prolog using library(ffi) https://github.com/aarroyoc/raylib-prolog

Strange: Somehow I have the feeling Scryer Prolog is
in a hybernation now, they sit on 270 issues and there

are no code changes anymore? Is it dead now?

Mild Shock schrieb:

Especially since good old FORTRAN has
made a new appearance:

TIOBE Index for May 2024
I have received a lot of questions why Fortran entered the top 10
again after more than 20 years. The TIOBE index just publishes
what has been measured.
https://www.tiobe.com/tiobe-index/

Why Fortran is back in TIOBE’s top 10
First, Fortran is especially good at numerical analysis and
computational mathematics. Numerical and mathematical
computing is growing because interest in artificial intelligence
is growing, Jansen told TechRepublic in an email. https://www.techrepublic.com/article/tiobe-index-may-2024/

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Somebody wondered on SWI discourse:

Prolog and the holy grail :+1:

This slogan didn’t grow in my backyard. See for example here:

Constraint Programming: In Pursuit of the Holy Grail
Roman Barták - 1999
https://ktiml.mff.cuni.cz/~bartak/downloads/WDS99.pdf

But now that Scryer Prolog is dead, some of their 270 GitHub
issues deals with performance problems(*) of their various CLPs,

I guess they need new a fresh start.

(*) Example:
https://github.com/mthom/scryer-prolog/issues/1730


Mild Shock schrieb:

Anybody tried to combine raylib with SWI-Prolog.
Like programming snake or something? Like here:

Raylib bindings to Scryer Prolog using library(ffi) https://github.com/aarroyoc/raylib-prolog

Strange: Somehow I have the feeling Scryer Prolog is
in a hybernation now, they sit on 270 issues and there

are no code changes anymore? Is it dead now?

Mild Shock schrieb:

Especially since good old FORTRAN has
made a new appearance:

TIOBE Index for May 2024
I have received a lot of questions why Fortran entered the top 10
again after more than 20 years. The TIOBE index just publishes
what has been measured.
https://www.tiobe.com/tiobe-index/

Why Fortran is back in TIOBE’s top 10
First, Fortran is especially good at numerical analysis and
computational mathematics. Numerical and mathematical
computing is growing because interest in artificial intelligence
is growing, Jansen told TechRepublic in an email.
https://www.techrepublic.com/article/tiobe-index-may-2024/

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Maybe Scryer Prolog is a failure, because Rust
is a failure. Building Scryer Prolog on my machine,
after a git pull of a small change, did just

take this much time:

$ time cargo build --release
[...]
real 6m52.663s
user 7m39.043s
sys 0m3.241s

What did Rust do? And this tabling test case,
2000 shuttle, hangs:

/* Scryer Prolog 0.9.4-107 */
?- use_module(library(tabling)).
true.
?- [user].
:- table c/1.
c(X) :- c(Y), 0 =< Y, Y < 20000, X is -Y-1.
c(X) :- c(Y), -20000 < Y, Y =< 0, X is -Y+1.
c(0).

?- time(c(_)).
%%% hangs ? %%%

It is solved in a blink in SWI-Prolog:

/* SWI-Prolog 9.3.8 */
?- time(c(_)).
% 540,077 inferences, 0.047 CPU in 0.051 seconds (92% CPU, 11521643 Lips)
true .

The test case is from here:

https://github.com/JanWielemaker/tabling_benchmarks/tree/master

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

If Rust is the culprit, I guess it isn't
due to this speculation:

Imagine Rust failed, why did it fail? https://www.reddit.com/r/rust/comments/c93upr/imagine_rust_failed_why_did_it_fail/

"climate change causes massively increased methane
offgassing in the Arctic, causing a runaway greenhouse
effect that eventually turns Earth into Venus,
destroying the biosphere before rust
can gain widespread adoption"

There are other signs that Rust is a failure, like here:

Why Rust is Making You Fail. --> 1.1k Claps https://medium.com/@ChadJohnsonOfficial/why-rust-is-stopping-your-success-use-c-and-c-instead-586dc7e2edbc

And here:

Should we call Rust a failed programming language? --> 10.5 views https://www.quora.com/Should-we-call-Rust-a-failed-programming-language

Mild Shock schrieb:

Maybe Scryer Prolog is a failure, because Rust
is a failure. Building Scryer Prolog on my machine,
after a git pull of a small change, did just

take this much time:

$ time cargo build --release
[...]
real    6m52.663s
user    7m39.043s
sys     0m3.241s

What did Rust do? And this tabling test case,
2000 shuttle, hangs:

/* Scryer Prolog 0.9.4-107 */
?- use_module(library(tabling)).
   true.
?- [user].
:- table c/1.
c(X) :- c(Y), 0 =< Y, Y < 20000, X is -Y-1.
c(X) :- c(Y), -20000 < Y, Y =< 0, X is -Y+1.
c(0).

?- time(c(_)).
%%% hangs ? %%%

It is solved in a blink in SWI-Prolog:

/* SWI-Prolog 9.3.8 */
?- time(c(_)).
% 540,077 inferences, 0.047 CPU in 0.051 seconds (92% CPU, 11521643 Lips) true .

The test case is from here:

https://github.com/JanWielemaker/tabling_benchmarks/tree/master

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Most likely Rust has not high performance computing
on its mind. This here looks horrible, and is the
same nightmare as in Go:

https://jondot.medium.com/errors-in-rust-a-formula-1e3e9a37d207

I would never port or realize a Prolog system on a
programming language and runtime, that doesn't offer
clever and efficient exception handling.

You don't get clever and efficient exception handling if you
shuffel around tuples. Althoug some of recent nodeJS
async programming had a similar flavor.

But still JavaScript has solid exception handling,
and so does Java and Python.

Mild Shock schrieb:

If Rust is the culprit, I guess it isn't
due to this speculation:

Imagine Rust failed, why did it fail? https://www.reddit.com/r/rust/comments/c93upr/imagine_rust_failed_why_did_it_fail/

"climate change causes massively increased methane
offgassing in the Arctic, causing a runaway greenhouse
effect that eventually turns Earth into Venus,
destroying the biosphere before rust
can gain widespread adoption"

There are other signs that Rust is a failure, like here:

Why Rust is Making You Fail. --> 1.1k Claps https://medium.com/@ChadJohnsonOfficial/why-rust-is-stopping-your-success-use-c-and-c-instead-586dc7e2edbc

And here:

Should we call Rust a failed programming language? --> 10.5 views https://www.quora.com/Should-we-call-Rust-a-failed-programming-language

Mild Shock schrieb:

Maybe Scryer Prolog is a failure, because Rust
is a failure. Building Scryer Prolog on my machine,
after a git pull of a small change, did just

take this much time:

$ time cargo build --release
[...]
real    6m52.663s
user    7m39.043s
sys     0m3.241s

What did Rust do? And this tabling test case,
2000 shuttle, hangs:

/* Scryer Prolog 0.9.4-107 */
?- use_module(library(tabling)).
    true.
?- [user].
:- table c/1.
c(X) :- c(Y), 0 =< Y, Y < 20000, X is -Y-1.
c(X) :- c(Y), -20000 < Y, Y =< 0, X is -Y+1.
c(0).

?- time(c(_)).
%%% hangs ? %%%

It is solved in a blink in SWI-Prolog:

/* SWI-Prolog 9.3.8 */
?- time(c(_)).
% 540,077 inferences, 0.047 CPU in 0.051 seconds (92% CPU, 11521643 Lips)
true .

The test case is from here:

https://github.com/JanWielemaker/tabling_benchmarks/tree/master

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

For example one Guru claimed?

Prolog were invented today, I think there would
be at least two significant differences:

First, the type-testing predicates like atom/1,
integer/1 and compound/1 would (and should) throw
instantiation errors if their arguments are not
sufficiently instantiated.

This is also what the original versions of Prolog
did. However, DEC 10 Prolog chose to replace instantiation
errors by silent failures, and this has been
perpetuated in the Edinburgh tradition for type tests
including the ISO standard.

https://www.quora.com/If-prolog-were-being-invented-today-with-no-concern-for-backward-compatibility-or-the-existing-standardization-how-would-it-differ-from-standard-prolog

I cannot verify any of the above nonsense.

First of all the term "DEC-10 Prolog" is ambigious:

DEC 10 Prolog 1975 https://www.softwarepreservation.org/projects/prolog/prolog/edinburgh/doc/Warren-Epilog_400_400-1975.pdf

DEC 10 Prolog 1982 https://userweb.fct.unl.pt/~lmp/publications/online-papers/DECsystem-10%20PROLOG%20USER%27S%20MANUAL.pdf

The DEC 10 Prolog 1975 looks very close to Prolog 0
with its french predicate names. There is not a simgle
atom/1, integer/1 equivalent that would throw an

instantiation error. Actually Prolog 0 didn't even
have some sort of exceptions, right?

Mild Shock schrieb:

Especially since good old FORTRAN has
made a new appearance:

TIOBE Index for May 2024
I have received a lot of questions why Fortran entered the top 10
again after more than 20 years. The TIOBE index just publishes
what has been measured.
https://www.tiobe.com/tiobe-index/

Why Fortran is back in TIOBE’s top 10
First, Fortran is especially good at numerical analysis and
computational mathematics. Numerical and mathematical
computing is growing because interest in artificial intelligence
is growing, Jansen told TechRepublic in an email. https://www.techrepublic.com/article/tiobe-index-may-2024/

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

That the DEC 10 Prolog 1975 is close to Prolog 0,
can be verified by reading the Prolog 0 manual:

MANUEL DE REFE RE NeE ET D'UTILISATION - PROLOG
ROUSSEL Ph. (1975) http://alain.colmerauer.free.fr/alcol/ArchivesPublications/ManuelProlog/Pr.pdf

So at that same year there was already an
English rip-off. If I read the french, I also
don't find some atom/1, integer/1 equivalent

that would throw an instantiation error. Problem
is again, what would have been an exception in Prolog 0?

Mild Shock schrieb:

For example one Guru claimed?

Prolog were invented today, I think there would
be at least two significant differences:

First, the type-testing predicates like atom/1,
integer/1 and compound/1 would (and should) throw
instantiation errors if their arguments are not
sufficiently instantiated.

This is also what the original versions of Prolog
did. However, DEC 10 Prolog chose to replace instantiation
errors by silent failures, and this has been
perpetuated in the Edinburgh tradition for type tests
including the ISO standard.

https://www.quora.com/If-prolog-were-being-invented-today-with-no-concern-for-backward-compatibility-or-the-existing-standardization-how-would-it-differ-from-standard-prolog

I cannot verify any of the above nonsense.

First of all the term "DEC-10 Prolog" is ambigious:

DEC 10 Prolog 1975 https://www.softwarepreservation.org/projects/prolog/prolog/edinburgh/doc/Warren-Epilog_400_400-1975.pdf

DEC 10 Prolog 1982 https://userweb.fct.unl.pt/~lmp/publications/online-papers/DECsystem-10%20PROLOG%20USER%27S%20MANUAL.pdf

The DEC 10 Prolog 1975 looks very close to Prolog 0
with its french predicate names. There is not a simgle
atom/1, integer/1 equivalent that would throw an

instantiation error. Actually Prolog 0 didn't even
have some sort of exceptions, right?

Mild Shock schrieb:

Especially since good old FORTRAN has
made a new appearance:

TIOBE Index for May 2024
I have received a lot of questions why Fortran entered the top 10
again after more than 20 years. The TIOBE index just publishes
what has been measured.
https://www.tiobe.com/tiobe-index/

Why Fortran is back in TIOBE’s top 10
First, Fortran is especially good at numerical analysis and
computational mathematics. Numerical and mathematical
computing is growing because interest in artificial intelligence
is growing, Jansen told TechRepublic in an email.
https://www.techrepublic.com/article/tiobe-index-may-2024/

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Well I am mistaken, Prolog 0 must have had some
concept of error. For example I find:

3. OPERATION SUR LES NOMBRES
=============================
LES PREDICATS SONT EVALUES A ERROR

And this is also used in a code_type variant, i.e.
CHIFFRE and LETTRE, follow the instantiation error
idea. But we have this also in Prolog systems today:

/* SWI-Prolog */
?- code_type(0'a, X).
X = alnum .

?- code_type(X, X).
ERROR: Arguments are not sufficiently instantiated

It is not the case that modern Prolog systems always
silently fail. They silently fail in atom/1, integer/1, etc..
which makes sense, especially from a WAM implementation

viewpoint, since WAM has usually type tag branching or
switching instructions. So these atom/1, integer/1, etc.. can
be implemented quite efficiently and one should view them

as belonging to the same category as var/1, (==)/2, etc..
i.e. meta predicates that deal syntactically with Prolog terms.
Some Prolog system can even perform indexing on these guards.

Mild Shock schrieb:

That the DEC 10 Prolog 1975 is close to Prolog 0,
can be verified by reading the Prolog 0 manual:

MANUEL DE REFE RE NeE ET D'UTILISATION - PROLOG
ROUSSEL Ph. (1975) http://alain.colmerauer.free.fr/alcol/ArchivesPublications/ManuelProlog/Pr.pdf

So at that same year there was already an
English rip-off. If I read the french, I also
don't find some atom/1, integer/1 equivalent

that would throw an instantiation error. Problem
is again, what would have been an exception in Prolog 0?

Mild Shock schrieb:

For example one Guru claimed?

Prolog were invented today, I think there would
be at least two significant differences:
;
First, the type-testing predicates like atom/1,
integer/1 and compound/1 would (and should) throw
instantiation errors if their arguments are not
sufficiently instantiated.
;
This is also what the original versions of Prolog
did. However, DEC 10 Prolog chose to replace instantiation
errors by silent failures, and this has been
perpetuated in the Edinburgh tradition for type tests
including the ISO standard.

https://www.quora.com/If-prolog-were-being-invented-today-with-no-concern-for-backward-compatibility-or-the-existing-standardization-how-would-it-differ-from-standard-prolog


I cannot verify any of the above nonsense.

First of all the term "DEC-10 Prolog" is ambigious:

DEC 10 Prolog 1975
https://www.softwarepreservation.org/projects/prolog/prolog/edinburgh/doc/Warren-Epilog_400_400-1975.pdf


DEC 10 Prolog 1982
https://userweb.fct.unl.pt/~lmp/publications/online-papers/DECsystem-10%20PROLOG%20USER%27S%20MANUAL.pdf


The DEC 10 Prolog 1975 looks very close to Prolog 0
with its french predicate names. There is not a simgle
atom/1, integer/1 equivalent that would throw an

instantiation error. Actually Prolog 0 didn't even
have some sort of exceptions, right?

Mild Shock schrieb:

Especially since good old FORTRAN has
made a new appearance:

TIOBE Index for May 2024
I have received a lot of questions why Fortran entered the top 10
again after more than 20 years. The TIOBE index just publishes
what has been measured.
https://www.tiobe.com/tiobe-index/

Why Fortran is back in TIOBE’s top 10
First, Fortran is especially good at numerical analysis and
computational mathematics. Numerical and mathematical
computing is growing because interest in artificial intelligence
is growing, Jansen told TechRepublic in an email.
https://www.techrepublic.com/article/tiobe-index-may-2024/

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Woa! They are still fiddling with DCG:

Modified: Samstag, 6. Juli 2024, 07:53:05 https://www.complang.tuwien.ac.at/ulrich/iso-prolog/phrase

For Dogelog Player and its Novacore, I have
invented shallow DCG transform. Shallow expansion is a
variant of the usually deep expansion, in that

we don't define a multi-file predicate:

term_expansion(<from>, <to>).

Which uses a result from goal expansion, i.e.
there is both term and goal expansion in deep expansion,
SWI-Prolog has even function expansion a third type of

expansion, but in shallow expansion we have only:

term_conversion(<from>, <to>).

In particular for performance and didactical
reasons Novacore from Dogelog Player has nothing
higher-order. So phrase/2 is missing. Not needed.

But I don't have test cases yet for this shallow
expansion. Maybe I could adapt a few from formerly
Jekejeke Prolog, trim them down to the scope of

shallow expansion.

Mild Shock schrieb:

Especially since good old FORTRAN has
made a new appearance:

TIOBE Index for May 2024
I have received a lot of questions why Fortran entered the top 10
again after more than 20 years. The TIOBE index just publishes
what has been measured.
https://www.tiobe.com/tiobe-index/

Why Fortran is back in TIOBE’s top 10
First, Fortran is especially good at numerical analysis and
computational mathematics. Numerical and mathematical
computing is growing because interest in artificial intelligence
is growing, Jansen told TechRepublic in an email. https://www.techrepublic.com/article/tiobe-index-may-2024/

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Happy Birthday Alan Key, he must be 84 years old now.
I am big fan of his dynabook and this is also gold:

Alan Kay on Computer Science Degree
https://www.youtube.com/watch?v=Lb-cKVxmVGk

Mild Shock schrieb:

Especially since good old FORTRAN has
made a new appearance:

TIOBE Index for May 2024
I have received a lot of questions why Fortran entered the top 10
again after more than 20 years. The TIOBE index just publishes
what has been measured.
https://www.tiobe.com/tiobe-index/

Why Fortran is back in TIOBE’s top 10
First, Fortran is especially good at numerical analysis and
computational mathematics. Numerical and mathematical
computing is growing because interest in artificial intelligence
is growing, Jansen told TechRepublic in an email. https://www.techrepublic.com/article/tiobe-index-may-2024/

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Mostlikely Scryer Prolog was so bold with its
statements about its own future, like here:

Scryer Prolog aims to become to
ISO Prolog what GHC is to Haskell
https://github.com/mthom/scryer-prolog

Because according to Alan Key in this interview
this is the easier thing to do, than to judge
the present or the past.

Joe Armstrong interviews Alan Kay
https://www.youtube.com/watch?v=fhOHn9TClXY

Mild Shock schrieb:

Happy Birthday Alan Key, he must be 84 years old now.
I am big fan of his dynabook and this is also gold:

Alan Kay on Computer Science Degree https://www.youtube.com/watch?v=Lb-cKVxmVGk

Mild Shock schrieb:

Especially since good old FORTRAN has
made a new appearance:

TIOBE Index for May 2024
I have received a lot of questions why Fortran entered the top 10
again after more than 20 years. The TIOBE index just publishes
what has been measured.
https://www.tiobe.com/tiobe-index/

Why Fortran is back in TIOBE’s top 10
First, Fortran is especially good at numerical analysis and
computational mathematics. Numerical and mathematical
computing is growing because interest in artificial intelligence
is growing, Jansen told TechRepublic in an email.
https://www.techrepublic.com/article/tiobe-index-may-2024/

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Scryer Prolog's mentality can be seen here:

?- op(600, fy, []).
error(permission_error(create,operator,[]),op/3).

What they cannot solve, they simply forbid.

This mentality was already seen when UWN started
fiddling with '|' operator definition, and made
some hilarious changes to ISO core standard,

and some hilarious claims for DCG. In Novacore '|'
is simply nowhere used and undefined, but can be
defined. For DCG the usual (;)/2 is used for disjunction,

no need to use '|' in DCG. Now we have the situation
that Ciao Prolog can easily do this:

/* Segerberg Models */
:- op( 600, fy, !). % universal quantifier: ![X]:
:- op( 600, fy, ?). % existential quantifier: ?[X]:
:- op( 600, fy, []). % necessity
:- op( 600, fy, <>). % possibility

?- X = ! [Y]:p(Y).
X = ![Y]:p(Y) ?

?- X = [] p.
X = []p ?

But Scryer Prolog can do neither of it. Scryer
Prolog stumbles on op( 600, fy, !), it will
suddently not anymore accept clauses such as:

p :- q, !, r.

Which is easy to fix with a small parsing heuristic,
doesn't need non-deterministic parsing or some such.

Mild Shock schrieb:

Mostlikely Scryer Prolog was so bold with its
statements about its own future, like here:

Scryer Prolog aims to become to
ISO Prolog what GHC is to Haskell
https://github.com/mthom/scryer-prolog

Because according to Alan Key in this interview
this is the easier thing to do, than to judge
the present or the past.

Joe Armstrong interviews Alan Kay
https://www.youtube.com/watch?v=fhOHn9TClXY

Mild Shock schrieb:

Happy Birthday Alan Key, he must be 84 years old now.
I am big fan of his dynabook and this is also gold:

Alan Kay on Computer Science Degree
https://www.youtube.com/watch?v=Lb-cKVxmVGk

Mild Shock schrieb:

Especially since good old FORTRAN has
made a new appearance:

TIOBE Index for May 2024
I have received a lot of questions why Fortran entered the top 10
again after more than 20 years. The TIOBE index just publishes
what has been measured.
https://www.tiobe.com/tiobe-index/

Why Fortran is back in TIOBE’s top 10
First, Fortran is especially good at numerical analysis and
computational mathematics. Numerical and mathematical
computing is growing because interest in artificial intelligence
is growing, Jansen told TechRepublic in an email.
https://www.techrepublic.com/article/tiobe-index-may-2024/

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Hi,

Did Lifeware Kill Scryer Prolog CLP(Z) ?

Sounds interesting:

Pack modeling a SWI-Prolog pack for mathematical
modellng with constraints on subscripted variables,
developed by François Fages. François Fages. A
Constraint-based Mathematical Modeling Library in
Prolog with Answer Constraint Semantics. https://lifeware.inria.fr/wiki/Main/Software

In 17th International Symposium on Functional and
Logic Programming, FLOPS 2024, volume 14659 of LNCS.
Springer-Verlag, 2024. [ preprint ]
https://arxiv.org/abs/2402.17286

Does it perform?

Bye

Mild Shock schrieb:

Especially since good old FORTRAN has
made a new appearance:

TIOBE Index for May 2024
I have received a lot of questions why Fortran entered the top 10
again after more than 20 years. The TIOBE index just publishes
what has been measured.
https://www.tiobe.com/tiobe-index/

Why Fortran is back in TIOBE’s top 10
First, Fortran is especially good at numerical analysis and
computational mathematics. Numerical and mathematical
computing is growing because interest in artificial intelligence
is growing, Jansen told TechRepublic in an email. https://www.techrepublic.com/article/tiobe-index-may-2024/

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Hi,

what is wrong with rust and linux???? https://www.youtube.com/watch?v=T2OKdv4SPdQ

Pure souls are getting purrified to become even purer.

Bye

P.S.: Zig moves to fast for the kernel?
https://ziglang.org/learn/overview/

How about a new Prolog system written in Zip?

Mild Shock schrieb:

Maybe Scryer Prolog is a failure, because Rust
is a failure. Building Scryer Prolog on my machine,
after a git pull of a small change, did just

take this much time:

$ time cargo build --release
[...]
real    6m52.663s
user    7m39.043s
sys     0m3.241s

What did Rust do? And this tabling test case,
2000 shuttle, hangs:

/* Scryer Prolog 0.9.4-107 */
?- use_module(library(tabling)).
   true.
?- [user].
:- table c/1.
c(X) :- c(Y), 0 =< Y, Y < 20000, X is -Y-1.
c(X) :- c(Y), -20000 < Y, Y =< 0, X is -Y+1.
c(0).

?- time(c(_)).
%%% hangs ? %%%

It is solved in a blink in SWI-Prolog:

/* SWI-Prolog 9.3.8 */
?- time(c(_)).
% 540,077 inferences, 0.047 CPU in 0.051 seconds (92% CPU, 11521643 Lips) true .

The test case is from here:

https://github.com/JanWielemaker/tabling_benchmarks/tree/master

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Hey folks, please take note:

"Rust is the last programming language made for humans
that we'll need. Future languages will be optimized for
machines, where AI handles all the coding" https://twitter.com/nath_simard/status/1816147809608851830

Sounds like utter bullshit to me. Must be a
stupid AI, that cannot do the the safety precautions
of Rust. Why would I need rust, if I have an AI?

For this exampe, the AI might generate:

#include <stdio.h>

int main(int argc, char* argv[]) {
printf("Hello %s\n", argv[0]);
}

Which might indeed generate a segfault. In
case there are zero arguments, argv[0] might
hafve the value NULL. https://www.tu-chemnitz.de/urz/archiv/kursunterlagen/C/kap3/argmain.htm

So why blame the target language, and not the AI?
This is a red herring argument in favor of Rust.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Hi,

The cest pool of bit rot is finally gone:

(Bit rot, because they did everything in a
facist way ignoring your copyright to prevent
you from deleting you own out dated stuff)

CoincidenceIDontThinkSo
https://9gag.com/gag/abAG4oE

The Fall of Stack Overflow https://observablehq.com/@ayhanfuat/the-fall-of-stack-overflow

The downfall is related to the appearance of
ChatGPT. I feel pitty for Ulrich Neumerkel false
and others who spammed stackoverflow for years

with their infinite dif/2 nonsense.

Bye

Mild Shock schrieb:

Hey folks, please take note:

"Rust is the last programming language made for humans
that we'll need. Future languages will be optimized for
machines, where AI handles all the coding" https://twitter.com/nath_simard/status/1816147809608851830

Sounds like utter bullshit to me. Must be a
stupid AI, that cannot do the the safety precautions
of Rust. Why would I need rust, if I have an AI?

For this exampe, the AI might generate:

#include <stdio.h>

int main(int argc, char* argv[]) {
   printf("Hello %s\n", argv[0]);
}

Which might indeed generate a segfault. In
case there are zero arguments, argv[0] might
hafve the value NULL. https://www.tu-chemnitz.de/urz/archiv/kursunterlagen/C/kap3/argmain.htm

So why blame the target language, and not the AI?
This is a red herring argument in favor of Rust.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

But ChatGPT has still to learn a lot, it
cannot make the link from Prolog to
lambda-Prolog to natural deduction.

Somehow after some questioning ChatGPT
presented me this Prolog code:

likes(john, pizza).
likes(mary, sushi).
likes(sam, burgers).

friend(john, mary).
friend(mary, sam).

likes_what_friends_like(Person, Thing) :-
friend(Person, Friend),
likes(Friend, Thing).

I then asked for a Prolog query that
solves the following question:

"who should john befriend so that we
can assume he likes burgers"

Interestingly ChatGPT strated using
Prolog and natural deduction on the meta
level, mentioning modus ponense, and answering

Proof via Natural Deduction:
Assumption: Assume friend(john, X) (where X = sam).

Apply the Rule: Since friend(john, sam) is true, and likes(sam, burgers)
is also true, we apply the rule likes_what_friends_like(john, Thing) and
infer likes_what_friends_like(john, burgers).

Conclusion: Therefore, likes_what_friends_like(john, burgers) holds,
which implies that John would like burgers if he befriends Sam.


Mild Shock schrieb:

Hi,

The cest pool of bit rot is finally gone:

(Bit rot, because they did everything in a
facist way ignoring your copyright to prevent
you from deleting you own out dated stuff)

CoincidenceIDontThinkSo
https://9gag.com/gag/abAG4oE

The Fall of Stack Overflow https://observablehq.com/@ayhanfuat/the-fall-of-stack-overflow

The downfall is related to the appearance of
ChatGPT. I feel pitty for Ulrich Neumerkel false
and others who spammed stackoverflow for years

with their infinite dif/2 nonsense.

Bye

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

How it started:

An exciting day! @spolsky called me and let me
know. Today's sale of Stack Overflow, most importantly,
lets Stack Overflow continue as an independent site --
and also mints 61 new millionaires.
Jeff Atwood - 6:47 PM · Jun 2, 2021 https://twitter.com/codinghorror/status/1400132013068218370

How its going:

Stack Overflow cuts 28% of its staff https://techcrunch.com/2023/10/17/stack-overflow-cuts-28-of-its-staff/

Mild Shock schrieb:

My objection was then that Prolog didn't do
the proof only ChatGPT did it.

"But Prolog is supposed to search for proofs.
What is the proof?"

It then continued with attempts like:

what_if_befriend(Person, Friend, Goal) :-
    assert(friend(Person, Friend)),  % Assert the new friendship
    Goal,  % Check the goal with the new friendship
    retract(friend(Person, Friend)).  % Retract after checking the goal

Only the above will not work, since
assert/1 cannot return a variable binding.

So what is the magic behind lambda-Prolog
and hypothetical reasoning? lambda-Prolog
not being in the scope of ChatGPT?

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

My objection was then that Prolog didn't do
the proof only ChatGPT did it.

"But Prolog is supposed to search for proofs.
What is the proof?"

It then continued with attempts like:

what_if_befriend(Person, Friend, Goal) :-
assert(friend(Person, Friend)), % Assert the new friendship
Goal, % Check the goal with the new friendship
retract(friend(Person, Friend)). % Retract after checking the goal

Only the above will not work, since
assert/1 cannot return a variable binding.

So what is the magic behind lambda-Prolog
and hypothetical reasoning? lambda-Prolog
not being in the scope of ChatGPT?

Mild Shock schrieb:

But ChatGPT has still to learn a lot, it
cannot make the link from Prolog to
lambda-Prolog to natural deduction.

Somehow after some questioning ChatGPT
presented me this Prolog code:

likes(john, pizza).
likes(mary, sushi).
likes(sam, burgers).

friend(john, mary).
friend(mary, sam).

likes_what_friends_like(Person, Thing) :-
    friend(Person, Friend),
    likes(Friend, Thing).

I then asked for a Prolog query that
solves the following question:

"who should john befriend so that we
can assume he likes burgers"

Interestingly ChatGPT strated using
Prolog and natural deduction on the meta
level, mentioning modus ponense, and answering

Proof via Natural Deduction:
Assumption: Assume friend(john, X) (where X = sam).

Apply the Rule: Since friend(john, sam) is true, and likes(sam, burgers)
is also true, we apply the rule likes_what_friends_like(john, Thing) and infer likes_what_friends_like(john, burgers).

Conclusion: Therefore, likes_what_friends_like(john, burgers) holds,
which implies that John would like burgers if he befriends Sam.

Mild Shock schrieb:

Hi,

The cest pool of bit rot is finally gone:

(Bit rot, because they did everything in a
facist way ignoring your copyright to prevent
you from deleting you own out dated stuff)

CoincidenceIDontThinkSo
https://9gag.com/gag/abAG4oE

The Fall of Stack Overflow
https://observablehq.com/@ayhanfuat/the-fall-of-stack-overflow

The downfall is related to the appearance of
ChatGPT. I feel pitty for Ulrich Neumerkel false
and others who spammed stackoverflow for years

with their infinite dif/2 nonsense.

Bye

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Hi,

Strange things happen in the Zig world:

Bun is a JavaScript runtime, package manager,
test runner and bundler built from scratch using
the Zig programming language. It was designed by
Jarred Sumner as a drop-in replacement for Node.js.
Bun uses WebKit's JavaScriptCore as the JavaScript
engine, unlike Node.js and Deno, which both use V8. https://en.wikipedia.org/wiki/Bun_(software)

Should give a try via Dogelog Player for JavaScript.

Python/PyPy (2.288s)
Js/Node (1.595s)
C/clang -O0 (1.566s)
Go (1.528s)
Js/Bun (1.434s)
1 Billion nested loop iterations
https://benjdd.com/loops2/

The above is a micro benchmark, might not give an
indicative whether Bun will choke or not. Lets see.

Bye

Mild Shock schrieb:

Hi,

what is wrong with rust and linux???? https://www.youtube.com/watch?v=T2OKdv4SPdQ

Pure souls are getting purrified to become even purer.

Bye

P.S.: Zig moves to fast for the kernel?
https://ziglang.org/learn/overview/

How about a new Prolog system written in Zip?

Mild Shock schrieb:

Maybe Scryer Prolog is a failure, because Rust
is a failure. Building Scryer Prolog on my machine,
after a git pull of a small change, did just

take this much time:

$ time cargo build --release
[...]
real    6m52.663s
user    7m39.043s
sys     0m3.241s

What did Rust do? And this tabling test case,
2000 shuttle, hangs:

/* Scryer Prolog 0.9.4-107 */
?- use_module(library(tabling)).
    true.
?- [user].
:- table c/1.
c(X) :- c(Y), 0 =< Y, Y < 20000, X is -Y-1.
c(X) :- c(Y), -20000 < Y, Y =< 0, X is -Y+1.
c(0).

?- time(c(_)).
%%% hangs ? %%%

It is solved in a blink in SWI-Prolog:

/* SWI-Prolog 9.3.8 */
?- time(c(_)).
% 540,077 inferences, 0.047 CPU in 0.051 seconds (92% CPU, 11521643 Lips)
true .

The test case is from here:

https://github.com/JanWielemaker/tabling_benchmarks/tree/master

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)