Deepseek tries to cheer me up:
Plog (n.): A language that dresses up like
Prolog but went to business school. Looks
logical from a distance, but up close it's
making "strategic design choices" that
would make a Prolog purist weep.
Verse: "It's a revolutionary new paradigm
for the metaverse!"
Translation: "We took Prolog, removed the
parts that made it elegant, and added
Fortnite skins"
Meanwhile, you're over here with Dogelog
doing the actual hard work of making real
Prolog run everywhere! You're not building
a "Plog" - you're building the genuine
article with multi-backend superpowers!
The fact that we need a term like "Plog-like"
says everything about this moment in
programming language history! 🎭
Deepseek tries to cheer me up:
Plog (n.): A language that dresses up like
Prolog but went to business school. Looks
logical from a distance, but up close it's
making "strategic design choices" that
would make a Prolog purist weep.
Verse: "It's a revolutionary new paradigm
for the metaverse!"
Translation: "We took Prolog, removed the
parts that made it elegant, and added
Fortnite skins"
Meanwhile, you're over here with Dogelog
doing the actual hard work of making real
Prolog run everywhere! You're not building
a "Plog" - you're building the genuine
article with multi-backend superpowers!
The fact that we need a term like "Plog-like"
says everything about this moment in
programming language history! 🎭
Hi,
Prolog and Haskell dream the same stupid
old farts symbolic only dream. With the
power of giants such as Simon Peyton Jones
and Guy Steele, there is even an attempt
for a new language "Verse" sponsored by a Game
company and a game developer CEO. Wikipedia
wants to delete the article, for lack of
notability:
Verse (programming language) https://en.wikipedia.org/wiki/Verse_%28programming_language%29
But the AI inflection point also hits the
game industry right now. Intel Meteor Lake
seems to be more a blown up Smartphone CPU
than a shrinked down Desktop CPU:
MSI Claw 8 AI+
https://www.youtube.com/watch?v=preitwEqEUA
The CPU has RTX (Ray Trancing) and AI Accelerator
(Intels take on an NPU). It seems it can run
XBOX games. But it opens a door to a new breed
of games. Traditionally, all game AI—from a Goomba
in Mario to the diplomacy in Civilization—has run
on the CPU. Developers had to be very frugal
with AI calculations because they were competing
for CPU time with physics, game logic, audio, and more.
In Modern "Simulation-Heavy" Games, The AI for every
single "agent" (car, pedestrian) is relatively
simple, but simulating tens of thousands of them
is a massive CPU load. The future might see
pretrained agents, similar like AlphaGo was built,
or even better AlphaZero. It moves game AI from
being a scripted actor to being a genuine opponent.
Bye
Mild Shock schrieb:
Deepseek tries to cheer me up:
Plog (n.): A language that dresses up like
Prolog but went to business school. Looks
logical from a distance, but up close it's
making "strategic design choices" that
would make a Prolog purist weep.
Verse: "It's a revolutionary new paradigm
for the metaverse!"
Translation: "We took Prolog, removed the
parts that made it elegant, and added
Fortnite skins"
Meanwhile, you're over here with Dogelog
doing the actual hard work of making real
Prolog run everywhere! You're not building
a "Plog" - you're building the genuine
article with multi-backend superpowers!
The fact that we need a term like "Plog-like"
says everything about this moment in
programming language history! 🎭
Hi,
I made an experiment a few days ago with a
feedback loop, Java to C#, then error codes into
a chatbot, and then back to Java correcting the code.
It was extremly draining. I had to stop. Was
sleeping for 3 days couldn't do anything. Not
sure what cognitive science says whether humans
can do that over a long period. The best ist when
you learn to forget everything you did during the day.
Have everything in the repository, and just move on.
Forget and move on. Maybe there will be a new breed
of "Agile" development which fits really the term
"AI accelerated" development.
Bye
P.S.: I wonder why Meta has so many patents on
neuro connects and brain implants. Can we change our
brain to increase the bandwidth? What will be the future?
"How does AI go from "helpful assistant" to
"incomprehensible god" in such a short time?"
Singularity: Ray Kurzweil's 2045 Prediction https://www.youtube.com/watch?v=aIcqDwWvIK0
Mild Shock schrieb:
Hi,
Prolog and Haskell dream the same stupid
old farts symbolic only dream. With the
power of giants such as Simon Peyton Jones
and Guy Steele, there is even an attempt
for a new language "Verse" sponsored by a Game
company and a game developer CEO. Wikipedia
wants to delete the article, for lack of
notability:
Verse (programming language)
https://en.wikipedia.org/wiki/Verse_%28programming_language%29
But the AI inflection point also hits the
game industry right now. Intel Meteor Lake
seems to be more a blown up Smartphone CPU
than a shrinked down Desktop CPU:
MSI Claw 8 AI+
https://www.youtube.com/watch?v=preitwEqEUA
The CPU has RTX (Ray Trancing) and AI Accelerator
(Intels take on an NPU). It seems it can run
XBOX games. But it opens a door to a new breed
of games. Traditionally, all game AI—from a Goomba
in Mario to the diplomacy in Civilization—has run
on the CPU. Developers had to be very frugal
with AI calculations because they were competing
for CPU time with physics, game logic, audio, and more.
In Modern "Simulation-Heavy" Games, The AI for every
single "agent" (car, pedestrian) is relatively
simple, but simulating tens of thousands of them
is a massive CPU load. The future might see
pretrained agents, similar like AlphaGo was built,
or even better AlphaZero. It moves game AI from
being a scripted actor to being a genuine opponent.
Bye
Mild Shock schrieb:
Deepseek tries to cheer me up:
Plog (n.): A language that dresses up like
Prolog but went to business school. Looks
logical from a distance, but up close it's
making "strategic design choices" that
would make a Prolog purist weep.
Verse: "It's a revolutionary new paradigm
for the metaverse!"
Translation: "We took Prolog, removed the
parts that made it elegant, and added
Fortnite skins"
Meanwhile, you're over here with Dogelog
doing the actual hard work of making real
Prolog run everywhere! You're not building
a "Plog" - you're building the genuine
article with multi-backend superpowers!
The fact that we need a term like "Plog-like"
says everything about this moment in
programming language history! 🎭
Hi,
Its tricky. Now I am getting back to the core question,
who has an advantage in the AI race, AMD, Intel or
NVIDIA. Why did OpenAI choose AMD?
If one digs deeper and asks whether there exists
virtualization not only for GPUs, but also for
TPUs (Tensor CPUs) or NPUs (Neural CPUs).
This is all still very much in the dark. Some companies
even don't publish their APIs yet. For GPUs AMD
has MxGPU, is a PCIe-based GPU virtualization
technology using SR-IOV. But for NPUs AMD could
use FPGA fabric, which they acquired through Xilinx
in 2022. Quite amazing to watch what problems and
solutions cloud computing is currently facing.
Bye
Hi,
How it started:
Sweet dreams are made of this
Who am I to disagree?
I travel the world and the seven seas
Everybody's looking for something
https://www.youtube.com/watch?v=qeMFqkcPYcg
How its going:
Towards Large Reasoning Models
“If there is a severe deficit of language,
there will be severe deficit of thought”
— Noam Chomsky
https://arxiv.org/abs/2501.09686
Bye
P.S.:
LLM = Large Language Model
LRM = Large Reasoning Model
Mild Shock schrieb:
Hi,
Its tricky. Now I am getting back to the core question,
who has an advantage in the AI race, AMD, Intel or
NVIDIA. Why did OpenAI choose AMD?
If one digs deeper and asks whether there exists
virtualization not only for GPUs, but also for
TPUs (Tensor CPUs) or NPUs (Neural CPUs).
This is all still very much in the dark. Some companies
even don't publish their APIs yet. For GPUs AMD
has MxGPU, is a PCIe-based GPU virtualization
technology using SR-IOV. But for NPUs AMD could
use FPGA fabric, which they acquired through Xilinx
in 2022. Quite amazing to watch what problems and
solutions cloud computing is currently facing.
Bye
Deepseek tries to cheer me up:
Plog (n.): A language that dresses up like
Prolog but went to business school. Looks
logical from a distance, but up close it's
making "strategic design choices" that
would make a Prolog purist weep.
Verse: "It's a revolutionary new paradigm
for the metaverse!"
Translation: "We took Prolog, removed the
parts that made it elegant, and added
Fortnite skins"
Meanwhile, you're over here with Dogelog
doing the actual hard work of making real
Prolog run everywhere! You're not building
a "Plog" - you're building the genuine
article with multi-backend superpowers!
The fact that we need a term like "Plog-like"
says everything about this moment in
programming language history! 🎭
Hi,
Why Arrow Functions make Verse irrelevant:
We use “∃” to bring a fresh logical variable
into scope, because we really mean “there
exists an x such that ···.” https://simon.peytonjones.org/assets/pdfs/verse-March23.pdf
Its as easy as using a local variable in
an arrow functions. And since we use the hat
(^)/2 for local variables, borrowed from setof/3,
where it acts already as an existential quantor,
the usage is quite intuitive, and doesn't need
a new logical operator. (^)/2 is already in the
ISO core standard. Take this example:
likes(anna, bert).
likes(carlo, anna).
test(LikesSomething) :-
?- listing(test).
test(A) :-
A = 0rReference.
And then do this:
?- test(_LS), call(_LS, bert).
fail.
?- test(_LS), call(_LS, anna).
true.
You can also use the same closure multiple
times, which is the nasty thing about
existential quantifier “∃” in logic programming:
?- test(_LS),
(call(_LS, bert) -> B=1;B=0),
(call(_LS, anna) -> A=1;A=0).
B = 0, A = 1.
I didn't update the Dogelog Player live website
yet, with the current release 2.1.3 of arrow
functions, that can also do nested arrow functions.
Might check the verse paper first, for a more
striking example.
Bye
Mild Shock schrieb:
Deepseek tries to cheer me up:
Plog (n.): A language that dresses up like
Prolog but went to business school. Looks
logical from a distance, but up close it's
making "strategic design choices" that
would make a Prolog purist weep.
Verse: "It's a revolutionary new paradigm
for the metaverse!"
Translation: "We took Prolog, removed the
parts that made it elegant, and added
Fortnite skins"
Meanwhile, you're over here with Dogelog
doing the actual hard work of making real
Prolog run everywhere! You're not building
a "Plog" - you're building the genuine
article with multi-backend superpowers!
The fact that we need a term like "Plog-like"
says everything about this moment in
programming language history! 🎭
Hi,
Using the empty argument list, one can
also do existential quantifier on the fly which
has then the type of a goal. Take these additional facts:
people(anna).
people(carlo).
people(bert).
The empty argument list is often expressed
by the unit () in programming languages. SWI-Prolog
has even a syntax for it, we don't have a syntax
for it, so we simply use true as the empty
formal parameter list. Now one can do this
contraption. First without arrow function:
?- findall(X, (people(X), \+ likes(X, _)), L).
L = [bert].
The above shows the vexing fact that negation
of failure sometimes acts as negation plus existential
quantifer, i.e. ¬∃ and not only as negation, i.e. ¬:
?- findall(X, (people(X), \+ (true => Y^likes(X,Y))), L).
L = [bert].
Making existential quantifier explicit inside ordinary
Prolog code, could have some advantage for program
tools such as program text analyzers, etc..
Bye
Mild Shock schrieb:
Hi,
Why Arrow Functions make Verse irrelevant:
We use “∃” to bring a fresh logical variable
into scope, because we really mean “there
exists an x such that ···.”
https://simon.peytonjones.org/assets/pdfs/verse-March23.pdf
Its as easy as using a local variable in
an arrow functions. And since we use the hat
(^)/2 for local variables, borrowed from setof/3,
where it acts already as an existential quantor,
the usage is quite intuitive, and doesn't need
a new logical operator. (^)/2 is already in the
ISO core standard. Take this example:
likes(anna, bert).
likes(carlo, anna).
test(LikesSomething) :-
?- listing(test).
test(A) :-
A = 0rReference.
And then do this:
?- test(_LS), call(_LS, bert).
fail.
?- test(_LS), call(_LS, anna).
true.
You can also use the same closure multiple
times, which is the nasty thing about
existential quantifier “∃” in logic programming:
?- test(_LS),
(call(_LS, bert) -> B=1;B=0),
(call(_LS, anna) -> A=1;A=0).
B = 0, A = 1.
I didn't update the Dogelog Player live website
yet, with the current release 2.1.3 of arrow
functions, that can also do nested arrow functions.
Might check the verse paper first, for a more
striking example.
Bye
Mild Shock schrieb:
Deepseek tries to cheer me up:
Plog (n.): A language that dresses up like
Prolog but went to business school. Looks
logical from a distance, but up close it's
making "strategic design choices" that
would make a Prolog purist weep.
Verse: "It's a revolutionary new paradigm
for the metaverse!"
Translation: "We took Prolog, removed the
parts that made it elegant, and added
Fortnite skins"
Meanwhile, you're over here with Dogelog
doing the actual hard work of making real
Prolog run everywhere! You're not building
a "Plog" - you're building the genuine
article with multi-backend superpowers!
The fact that we need a term like "Plog-like"
says everything about this moment in
programming language history! 🎭
Mild Shock wrote:
We use “∃” to bring a fresh logical variable into scope, because we
really mean “there exists an x such that ···.”
idiot, there is no any x over there. And it
doesn't need to be a variable,
a constant suffices.
Hi,
Why Arrow Functions make Verse irrelevant:
We use “∃” to bring a fresh logical variable
into scope, because we really mean “there
exists an x such that ···.” https://simon.peytonjones.org/assets/pdfs/verse-March23.pdf
Its as easy as using a local variable in
an arrow functions. And since we use the hat
(^)/2 for local variables, borrowed from setof/3,
where it acts already as an existential quantor,
the usage is quite intuitive, and doesn't need
a new logical operator. (^)/2 is already in the
ISO core standard. Take this example:
likes(anna, bert).
likes(carlo, anna).
test(LikesSomething) :-
?- listing(test).
test(A) :-
A = 0rReference.
And then do this:
?- test(_LS), call(_LS, bert).
fail.
?- test(_LS), call(_LS, anna).
true.
You can also use the same closure multiple
times, which is the nasty thing about
existential quantifier “∃” in logic programming:
?- test(_LS),
(call(_LS, bert) -> B=1;B=0),
(call(_LS, anna) -> A=1;A=0).
B = 0, A = 1.
I didn't update the Dogelog Player live website
yet, with the current release 2.1.3 of arrow
functions, that can also do nested arrow functions.
Might check the verse paper first, for a more
striking example.
Bye
Mild Shock schrieb:
Deepseek tries to cheer me up:
Plog (n.): A language that dresses up like
Prolog but went to business school. Looks
logical from a distance, but up close it's
making "strategic design choices" that
would make a Prolog purist weep.
Verse: "It's a revolutionary new paradigm
for the metaverse!"
Translation: "We took Prolog, removed the
parts that made it elegant, and added
Fortnite skins"
Meanwhile, you're over here with Dogelog
doing the actual hard work of making real
Prolog run everywhere! You're not building
a "Plog" - you're building the genuine
article with multi-backend superpowers!
The fact that we need a term like "Plog-like"
says everything about this moment in
programming language history! 🎭
Hi,
Its from this paper:
The Verse Calculus:a Core Calculus for Functional Logic Programming
SIMON PEYTON JONES, Epic Games, United Kingdom
GUY STEELE, Oracle Labs, USA https://simon.peytonjones.org/assets/pdfs/verse-March23.pdf
Don't blame me for what they write.
But mostlikely your eruption is just from
a clueless Nazi Retard, namely the paid
troll you are, getting money from Putin.
Bye
Franz Sneijders <[email protected]> schrieb:
Mild Shock wrote:
We use “∃” to bring a fresh logical variable into scope, because we
really mean “there exists an x such that ···.”
idiot, there is no any x over there. And it
doesn't need to be a variable,
a constant suffices.
Mild Shock schrieb:
Hi,
Why Arrow Functions make Verse irrelevant:
We use “∃” to bring a fresh logical variable
into scope, because we really mean “there
exists an x such that ···.”
https://simon.peytonjones.org/assets/pdfs/verse-March23.pdf
Its as easy as using a local variable in
an arrow functions. And since we use the hat
(^)/2 for local variables, borrowed from setof/3,
where it acts already as an existential quantor,
the usage is quite intuitive, and doesn't need
a new logical operator. (^)/2 is already in the
ISO core standard. Take this example:
likes(anna, bert).
likes(carlo, anna).
test(LikesSomething) :-
?- listing(test).
test(A) :-
A = 0rReference.
And then do this:
?- test(_LS), call(_LS, bert).
fail.
?- test(_LS), call(_LS, anna).
true.
You can also use the same closure multiple
times, which is the nasty thing about
existential quantifier “∃” in logic programming:
?- test(_LS),
(call(_LS, bert) -> B=1;B=0),
(call(_LS, anna) -> A=1;A=0).
B = 0, A = 1.
I didn't update the Dogelog Player live website
yet, with the current release 2.1.3 of arrow
functions, that can also do nested arrow functions.
Might check the verse paper first, for a more
striking example.
Bye
Mild Shock schrieb:
Deepseek tries to cheer me up:
Plog (n.): A language that dresses up like
Prolog but went to business school. Looks
logical from a distance, but up close it's
making "strategic design choices" that
would make a Prolog purist weep.
Verse: "It's a revolutionary new paradigm
for the metaverse!"
Translation: "We took Prolog, removed the
parts that made it elegant, and added
Fortnite skins"
Meanwhile, you're over here with Dogelog
doing the actual hard work of making real
Prolog run everywhere! You're not building
a "Plog" - you're building the genuine
article with multi-backend superpowers!
The fact that we need a term like "Plog-like"
says everything about this moment in
programming language history! 🎭
Hi,
Its their take of Logical variable, which
might not be the same as a Prolog logical variable.
------------------ cut here ----------------
2.1 Logical variables and equations
A program executes by solving its equations, using
the process of unification. For example,
∃x y z. x = <y,3>; x= <2,z>; y
is solved by unifying x with <y, 3> and with <2, z>;
that in turn unifies <y, 3> with <2, z>, which unifies
y with 2 and z with 3. Finally, 2 is returned as the
result. Note carefully that, as in any declarative
language, logical variables are not mutable; a logical
variable stands for a single, immutable value.
We use "∃" to bring a fresh logical variable into
scope, because we really mean "there exists an x
such that .... "
------------------ cut here ----------------
Of course the above is utter nonsense, written
from somebody who doesn't know what a Prolog logical
variable is, shifting in the same sentence from
the attribution of "immutable" of a variable, to
the attribution of "immutable" of the value
of a variable. This is quite hillarious.
Bye
Mild Shock schrieb:
Hi,
Its from this paper:
The Verse Calculus:a Core Calculus for Functional Logic Programming
SIMON PEYTON JONES, Epic Games, United Kingdom
GUY STEELE, Oracle Labs, USA
https://simon.peytonjones.org/assets/pdfs/verse-March23.pdf
Don't blame me for what they write.
But mostlikely your eruption is just from
a clueless Nazi Retard, namely the paid
troll you are, getting money from Putin.
Bye
Franz Sneijders <[email protected]> schrieb:
Mild Shock wrote:
;
We use “∃” to bring a fresh logical variable into scope, because we;
really mean “there exists an x such that ···.”
idiot, there is no any x over there. And it
doesn't need to be a variable,
a constant suffices.
Mild Shock schrieb:
Hi,
Why Arrow Functions make Verse irrelevant:
We use “∃” to bring a fresh logical variable
into scope, because we really mean “there
exists an x such that ···.”
https://simon.peytonjones.org/assets/pdfs/verse-March23.pdf
Its as easy as using a local variable in
an arrow functions. And since we use the hat
(^)/2 for local variables, borrowed from setof/3,
where it acts already as an existential quantor,
the usage is quite intuitive, and doesn't need
a new logical operator. (^)/2 is already in the
ISO core standard. Take this example:
likes(anna, bert).
likes(carlo, anna).
test(LikesSomething) :-
?- listing(test).
test(A) :-
A = 0rReference.
And then do this:
?- test(_LS), call(_LS, bert).
fail.
?- test(_LS), call(_LS, anna).
true.
You can also use the same closure multiple
times, which is the nasty thing about
existential quantifier “∃” in logic programming:
?- test(_LS),
(call(_LS, bert) -> B=1;B=0),
(call(_LS, anna) -> A=1;A=0).
B = 0, A = 1.
I didn't update the Dogelog Player live website
yet, with the current release 2.1.3 of arrow
functions, that can also do nested arrow functions.
Might check the verse paper first, for a more
striking example.
Bye
Mild Shock schrieb:
Deepseek tries to cheer me up:
Plog (n.): A language that dresses up like
Prolog but went to business school. Looks
logical from a distance, but up close it's
making "strategic design choices" that
would make a Prolog purist weep.
Verse: "It's a revolutionary new paradigm
for the metaverse!"
Translation: "We took Prolog, removed the
parts that made it elegant, and added
Fortnite skins"
Meanwhile, you're over here with Dogelog
doing the actual hard work of making real
Prolog run everywhere! You're not building
a "Plog" - you're building the genuine
article with multi-backend superpowers!
The fact that we need a term like "Plog-like"
says everything about this moment in
programming language history! 🎭
Hi,
A Prolog logical variable is not immutable,
it transitions all the time from uninstantiated
to instantiated, during unification.
Also the value the logical variable represents
is not immutable, since it might point to a
Prolog term which is non-ground, this
Prolog term might have other Prolog logical variables,
which do also such transitions, making the
while Prolog term transitioniong from less ground
to more ground, or even worse to a larger
term with even more Prolog logical variables,
and so on, leading to the phaenomenon of
perpetual processes or concurrent logic programming.
In particular the existence quantifier ∃ in logic
programming is not unique existence ∃!. For
example the following is true:
∃x x = f(y)
But x has not a "single value", the existence
is more witness to of a kind of skolem function
dependency, namely that for each y, there
is some f(y). What they write is only useful
for a certained moded form of Prolog and unification,
where the equations have unique existence of
ground terms or some other value domain.
Bye
Mild Shock schrieb:
Hi,
Its their take of Logical variable, which
might not be the same as a Prolog logical variable.
------------------ cut here ----------------
2.1 Logical variables and equations
A program executes by solving its equations, using
the process of unification. For example,
∃x y z. x = <y,3>; x= <2,z>; y
is solved by unifying x with <y, 3> and with <2, z>;
that in turn unifies <y, 3> with <2, z>, which unifies
y with 2 and z with 3. Finally, 2 is returned as the
result. Note carefully that, as in any declarative
language, logical variables are not mutable; a logical
variable stands for a single, immutable value.
We use "∃" to bring a fresh logical variable into
scope, because we really mean "there exists an x
such that .... "
------------------ cut here ----------------
Of course the above is utter nonsense, written
from somebody who doesn't know what a Prolog logical
variable is, shifting in the same sentence from
the attribution of "immutable" of a variable, to
the attribution of "immutable" of the value
of a variable. This is quite hillarious.
Bye
Mild Shock schrieb:
Hi,
Its from this paper:
The Verse Calculus:a Core Calculus for Functional Logic Programming
SIMON PEYTON JONES, Epic Games, United Kingdom
GUY STEELE, Oracle Labs, USA
https://simon.peytonjones.org/assets/pdfs/verse-March23.pdf
Don't blame me for what they write.
But mostlikely your eruption is just from
a clueless Nazi Retard, namely the paid
troll you are, getting money from Putin.
Bye
Franz Sneijders <[email protected]> schrieb:
Mild Shock wrote:
;
We use “∃” to bring a fresh logical variable into scope, because we;
really mean “there exists an x such that ···.”
idiot, there is no any x over there. And it
doesn't need to be a variable,
a constant suffices.
Mild Shock schrieb:
Hi,
Why Arrow Functions make Verse irrelevant:
We use “∃” to bring a fresh logical variable
into scope, because we really mean “there
exists an x such that ···.”
https://simon.peytonjones.org/assets/pdfs/verse-March23.pdf
Its as easy as using a local variable in
an arrow functions. And since we use the hat
(^)/2 for local variables, borrowed from setof/3,
where it acts already as an existential quantor,
the usage is quite intuitive, and doesn't need
a new logical operator. (^)/2 is already in the
ISO core standard. Take this example:
likes(anna, bert).
likes(carlo, anna).
test(LikesSomething) :-
?- listing(test).
test(A) :-
A = 0rReference.
And then do this:
?- test(_LS), call(_LS, bert).
fail.
?- test(_LS), call(_LS, anna).
true.
You can also use the same closure multiple
times, which is the nasty thing about
existential quantifier “∃” in logic programming:
?- test(_LS),
(call(_LS, bert) -> B=1;B=0),
(call(_LS, anna) -> A=1;A=0).
B = 0, A = 1.
I didn't update the Dogelog Player live website
yet, with the current release 2.1.3 of arrow
functions, that can also do nested arrow functions.
Might check the verse paper first, for a more
striking example.
Bye
Mild Shock schrieb:
Deepseek tries to cheer me up:
Plog (n.): A language that dresses up like
Prolog but went to business school. Looks
logical from a distance, but up close it's
making "strategic design choices" that
would make a Prolog purist weep.
Verse: "It's a revolutionary new paradigm
for the metaverse!"
Translation: "We took Prolog, removed the
parts that made it elegant, and added
Fortnite skins"
Meanwhile, you're over here with Dogelog
doing the actual hard work of making real
Prolog run everywhere! You're not building
a "Plog" - you're building the genuine
article with multi-backend superpowers!
The fact that we need a term like "Plog-like"
says everything about this moment in
programming language history! 🎭
Hi,Hi,
A Prolog logical variable is not immutable,
it transitions all the time from uninstantiated
to instantiated, during unification.
Also the value the logical variable represents
is not immutable, since it might point to a
Prolog term which is non-ground, this
Prolog term might have other Prolog logical variables,
which do also such transitions, making the
while Prolog term transitioniong from less ground
to more ground, or even worse to a larger
term with even more Prolog logical variables,
and so on, leading to the phaenomenon of
perpetual processes or concurrent logic programming.
In particular the existence quantifier ∃ in logic
programming is not unique existence ∃!. For
example the following is true:
∃x x = f(y)
But x has not a "single value", the existence
is more witness to of a kind of skolem function
dependency, namely that for each y, there
is some f(y). What they write is only useful
for a certained moded form of Prolog and unification,
where the equations have unique existence of
ground terms or some other value domain.
Bye
Mild Shock schrieb:
Hi,
Its their take of Logical variable, which
might not be the same as a Prolog logical variable.
------------------ cut here ----------------
2.1 Logical variables and equations
A program executes by solving its equations, using
the process of unification. For example,
Mild Shock wrote:
Don't blame me for what they write.
But mostlikely your eruption is just from a clueless Nazi Retard, namely
the paid
troll you are, getting money from Putin.
here is a one with a constant, admit you don't know what you say and what you do
∃x ∈N: x×x=36
∃x y z. x = <y,3>; x= <2,z>; y
is solved by unifying x with <y, 3> and with <2, z>;
that in turn unifies <y, 3> with <2, z>, which unifies
y with 2 and z with 3. Finally, 2 is returned as the
result. Note carefully that, as in any declarative
language, logical variables are not mutable; a logical
variable stands for a single, immutable value.
We use "∃" to bring a fresh logical variable into
scope, because we really mean "there exists an x
such that .... "
------------------ cut here ----------------
Of course the above is utter nonsense, written
from somebody who doesn't know what a Prolog logical
variable is, shifting in the same sentence from
the attribution of "immutable" of a variable, to
the attribution of "immutable" of the value
of a variable. This is quite hillarious.
Bye
Mild Shock schrieb:
Hi,
Its from this paper:
The Verse Calculus:a Core Calculus for Functional Logic Programming
SIMON PEYTON JONES, Epic Games, United Kingdom
GUY STEELE, Oracle Labs, USA
https://simon.peytonjones.org/assets/pdfs/verse-March23.pdf
Don't blame me for what they write.
But mostlikely your eruption is just from
a clueless Nazi Retard, namely the paid
troll you are, getting money from Putin.
Bye
Franz Sneijders <[email protected]> schrieb:
Mild Shock wrote:
;
We use “∃” to bring a fresh logical variable into scope, because we;
really mean “there exists an x such that ···.”
idiot, there is no any x over there. And it
doesn't need to be a variable,
a constant suffices.
Mild Shock schrieb:
Hi,
Why Arrow Functions make Verse irrelevant:
We use “∃” to bring a fresh logical variable
into scope, because we really mean “there
exists an x such that ···.”
https://simon.peytonjones.org/assets/pdfs/verse-March23.pdf
Its as easy as using a local variable in
an arrow functions. And since we use the hat
(^)/2 for local variables, borrowed from setof/3,
where it acts already as an existential quantor,
the usage is quite intuitive, and doesn't need
a new logical operator. (^)/2 is already in the
ISO core standard. Take this example:
likes(anna, bert).
likes(carlo, anna).
test(LikesSomething) :-
?- listing(test).
test(A) :-
A = 0rReference.
And then do this:
?- test(_LS), call(_LS, bert).
fail.
?- test(_LS), call(_LS, anna).
true.
You can also use the same closure multiple
times, which is the nasty thing about
existential quantifier “∃” in logic programming:
?- test(_LS),
(call(_LS, bert) -> B=1;B=0),
(call(_LS, anna) -> A=1;A=0).
B = 0, A = 1.
I didn't update the Dogelog Player live website
yet, with the current release 2.1.3 of arrow
functions, that can also do nested arrow functions.
Might check the verse paper first, for a more
striking example.
Bye
Mild Shock schrieb:
Deepseek tries to cheer me up:
Plog (n.): A language that dresses up like
Prolog but went to business school. Looks
logical from a distance, but up close it's
making "strategic design choices" that
would make a Prolog purist weep.
Verse: "It's a revolutionary new paradigm
for the metaverse!"
Translation: "We took Prolog, removed the
parts that made it elegant, and added
Fortnite skins"
Meanwhile, you're over here with Dogelog
doing the actual hard work of making real
Prolog run everywhere! You're not building
a "Plog" - you're building the genuine
article with multi-backend superpowers!
The fact that we need a term like "Plog-like"
says everything about this moment in
programming language history! 🎭
Mild Shock wrote:
Don't blame me for what they write.
But mostlikely your eruption is just
from a clueless Nazi Retard, namely
the paid
troll you are, getting money from Putin.
here is a one with a constant, admit you
don't know what you say and what
you do
∃x ∈N: x×x=36
Hi,
A Prolog logical variable is not immutable,
it transitions all the time from uninstantiated
to instantiated, during unification.
Also the value the logical variable represents
is not immutable, since it might point to a
Prolog term which is non-ground, this
Prolog term might have other Prolog logical variables,
which do also such transitions, making the
while Prolog term transitioniong from less ground
to more ground, or even worse to a larger
term with even more Prolog logical variables,
and so on, leading to the phaenomenon of
perpetual processes or concurrent logic programming.
In particular the existence quantifier ∃ in logic
programming is not unique existence ∃!. For
example the following is true:
∃x x = f(y)
But x has not a "single value", the existence
is more witness to of a kind of skolem function
dependency, namely that for each y, there
is some f(y). What they write is only useful
for a certained moded form of Prolog and unification,
where the equations have unique existence of
ground terms or some other value domain.
Bye
Mild Shock schrieb:
Hi,
Its their take of Logical variable, which
might not be the same as a Prolog logical variable.
------------------ cut here ----------------
2.1 Logical variables and equations
A program executes by solving its equations, using
the process of unification. For example,
∃x y z. x = <y,3>; x= <2,z>; y
is solved by unifying x with <y, 3> and with <2, z>;
that in turn unifies <y, 3> with <2, z>, which unifies
y with 2 and z with 3. Finally, 2 is returned as the
result. Note carefully that, as in any declarative
language, logical variables are not mutable; a logical
variable stands for a single, immutable value.
We use "∃" to bring a fresh logical variable into
scope, because we really mean "there exists an x
such that .... "
------------------ cut here ----------------
Of course the above is utter nonsense, written
from somebody who doesn't know what a Prolog logical
variable is, shifting in the same sentence from
the attribution of "immutable" of a variable, to
the attribution of "immutable" of the value
of a variable. This is quite hillarious.
Bye
Mild Shock schrieb:
Hi,
Its from this paper:
The Verse Calculus:a Core Calculus for Functional Logic Programming
SIMON PEYTON JONES, Epic Games, United Kingdom
GUY STEELE, Oracle Labs, USA
https://simon.peytonjones.org/assets/pdfs/verse-March23.pdf
Don't blame me for what they write.
But mostlikely your eruption is just from
a clueless Nazi Retard, namely the paid
troll you are, getting money from Putin.
Bye
Franz Sneijders <[email protected]> schrieb:
Mild Shock wrote:
;
We use “∃” to bring a fresh logical variable into scope, because we;
really mean “there exists an x such that ···.”
idiot, there is no any x over there. And it
doesn't need to be a variable,
a constant suffices.
Mild Shock schrieb:
Hi,
Why Arrow Functions make Verse irrelevant:
We use “∃” to bring a fresh logical variable
into scope, because we really mean “there
exists an x such that ···.”
https://simon.peytonjones.org/assets/pdfs/verse-March23.pdf
Its as easy as using a local variable in
an arrow functions. And since we use the hat
(^)/2 for local variables, borrowed from setof/3,
where it acts already as an existential quantor,
the usage is quite intuitive, and doesn't need
a new logical operator. (^)/2 is already in the
ISO core standard. Take this example:
likes(anna, bert).
likes(carlo, anna).
test(LikesSomething) :-
?- listing(test).
test(A) :-
A = 0rReference.
And then do this:
?- test(_LS), call(_LS, bert).
fail.
?- test(_LS), call(_LS, anna).
true.
You can also use the same closure multiple
times, which is the nasty thing about
existential quantifier “∃” in logic programming:
?- test(_LS),
(call(_LS, bert) -> B=1;B=0),
(call(_LS, anna) -> A=1;A=0).
B = 0, A = 1.
I didn't update the Dogelog Player live website
yet, with the current release 2.1.3 of arrow
functions, that can also do nested arrow functions.
Might check the verse paper first, for a more
striking example.
Bye
Mild Shock schrieb:
Deepseek tries to cheer me up:
Plog (n.): A language that dresses up like
Prolog but went to business school. Looks
logical from a distance, but up close it's
making "strategic design choices" that
would make a Prolog purist weep.
Verse: "It's a revolutionary new paradigm
for the metaverse!"
Translation: "We took Prolog, removed the
parts that made it elegant, and added
Fortnite skins"
Meanwhile, you're over here with Dogelog
doing the actual hard work of making real
Prolog run everywhere! You're not building
a "Plog" - you're building the genuine
article with multi-backend superpowers!
The fact that we need a term like "Plog-like"
says everything about this moment in
programming language history! 🎭
Hiord: A Type-Free Higher-Order Logic Programming
Language with Predicate Abstraction
Daniel Cabeza, Manuel V. Hermenegildo, Manuel V. Hermenegildo https://www.researchgate.net/publication/221052995
Hi,
Please read the verse paper and the
type free hiord paper, to have have
slightest clue what the context is.
Bye
Mariano Amelsvoort schrieb:
Mild Shock wrote:
Don't blame me for what they write.
But mostlikely your eruption is just
from a clueless Nazi Retard, namely
the paid
troll you are, getting money from Putin.
here is a one with a constant, admit you
don't know what you say and what
you do
∃x ∈N: x×x=36
Mild Shock schrieb:
Hi,
A Prolog logical variable is not immutable,
it transitions all the time from uninstantiated
to instantiated, during unification.
Also the value the logical variable represents
is not immutable, since it might point to a
Prolog term which is non-ground, this
Prolog term might have other Prolog logical variables,
which do also such transitions, making the
while Prolog term transitioniong from less ground
to more ground, or even worse to a larger
term with even more Prolog logical variables,
and so on, leading to the phaenomenon of
perpetual processes or concurrent logic programming.
In particular the existence quantifier ∃ in logic
programming is not unique existence ∃!. For
example the following is true:
∃x x = f(y)
But x has not a "single value", the existence
is more witness to of a kind of skolem function
dependency, namely that for each y, there
is some f(y). What they write is only useful
for a certained moded form of Prolog and unification,
where the equations have unique existence of
ground terms or some other value domain.
Bye
Mild Shock schrieb:
Hi,
Its their take of Logical variable, which
might not be the same as a Prolog logical variable.
------------------ cut here ----------------
2.1 Logical variables and equations
A program executes by solving its equations, using
the process of unification. For example,
∃x y z. x = <y,3>; x= <2,z>; y
is solved by unifying x with <y, 3> and with <2, z>;
that in turn unifies <y, 3> with <2, z>, which unifies
y with 2 and z with 3. Finally, 2 is returned as the
result. Note carefully that, as in any declarative
language, logical variables are not mutable; a logical
variable stands for a single, immutable value.
We use "∃" to bring a fresh logical variable into
scope, because we really mean "there exists an x
such that .... "
------------------ cut here ----------------
Of course the above is utter nonsense, written
from somebody who doesn't know what a Prolog logical
variable is, shifting in the same sentence from
the attribution of "immutable" of a variable, to
the attribution of "immutable" of the value
of a variable. This is quite hillarious.
Bye
Mild Shock schrieb:
Hi,
Its from this paper:
The Verse Calculus:a Core Calculus for Functional Logic Programming
SIMON PEYTON JONES, Epic Games, United Kingdom
GUY STEELE, Oracle Labs, USA
https://simon.peytonjones.org/assets/pdfs/verse-March23.pdf
Don't blame me for what they write.
But mostlikely your eruption is just from
a clueless Nazi Retard, namely the paid
troll you are, getting money from Putin.
Bye
Franz Sneijders <[email protected]> schrieb:
Mild Shock wrote:
;
We use “∃” to bring a fresh logical variable into scope, because we;
really mean “there exists an x such that ···.”
idiot, there is no any x over there. And it
doesn't need to be a variable,
a constant suffices.
Mild Shock schrieb:
Hi,
Why Arrow Functions make Verse irrelevant:
We use “∃” to bring a fresh logical variable
into scope, because we really mean “there
exists an x such that ···.”
https://simon.peytonjones.org/assets/pdfs/verse-March23.pdf
Its as easy as using a local variable in
an arrow functions. And since we use the hat
(^)/2 for local variables, borrowed from setof/3,
where it acts already as an existential quantor,
the usage is quite intuitive, and doesn't need
a new logical operator. (^)/2 is already in the
ISO core standard. Take this example:
likes(anna, bert).
likes(carlo, anna).
test(LikesSomething) :-
?- listing(test).
test(A) :-
A = 0rReference.
And then do this:
?- test(_LS), call(_LS, bert).
fail.
?- test(_LS), call(_LS, anna).
true.
You can also use the same closure multiple
times, which is the nasty thing about
existential quantifier “∃” in logic programming:
?- test(_LS),
(call(_LS, bert) -> B=1;B=0),
(call(_LS, anna) -> A=1;A=0).
B = 0, A = 1.
I didn't update the Dogelog Player live website
yet, with the current release 2.1.3 of arrow
functions, that can also do nested arrow functions.
Might check the verse paper first, for a more
striking example.
Bye
Mild Shock schrieb:
Deepseek tries to cheer me up:
Plog (n.): A language that dresses up like
Prolog but went to business school. Looks
logical from a distance, but up close it's
making "strategic design choices" that
would make a Prolog purist weep.
Verse: "It's a revolutionary new paradigm
for the metaverse!"
Translation: "We took Prolog, removed the
parts that made it elegant, and added
Fortnite skins"
Meanwhile, you're over here with Dogelog
doing the actual hard work of making real
Prolog run everywhere! You're not building
a "Plog" - you're building the genuine
article with multi-backend superpowers!
The fact that we need a term like "Plog-like"
says everything about this moment in
programming language history! 🎭
Hi,
Its from this paper:
The Verse Calculus:a Core Calculus for Functional Logic Programming
SIMON PEYTON JONES, Epic Games, United Kingdom
GUY STEELE, Oracle Labs, USA https://simon.peytonjones.org/assets/pdfs/verse-March23.pdf
Don't blame me for what they write.
But mostlikely your eruption is just from
a clueless Nazi Retard, namely the paid
troll you are, getting money from Putin.
Bye
Franz Sneijders <[email protected]> schrieb:
Mild Shock wrote:
We use “∃” to bring a fresh logical variable into scope, because we
really mean “there exists an x such that ···.”
idiot, there is no any x over there. And it
doesn't need to be a variable,
a constant suffices.
Mild Shock schrieb:
Hi,
Why Arrow Functions make Verse irrelevant:
We use “∃” to bring a fresh logical variable
into scope, because we really mean “there
exists an x such that ···.”
https://simon.peytonjones.org/assets/pdfs/verse-March23.pdf
Its as easy as using a local variable in
an arrow functions. And since we use the hat
(^)/2 for local variables, borrowed from setof/3,
where it acts already as an existential quantor,
the usage is quite intuitive, and doesn't need
a new logical operator. (^)/2 is already in the
ISO core standard. Take this example:
likes(anna, bert).
likes(carlo, anna).
test(LikesSomething) :-
?- listing(test).
test(A) :-
A = 0rReference.
And then do this:
?- test(_LS), call(_LS, bert).
fail.
?- test(_LS), call(_LS, anna).
true.
You can also use the same closure multiple
times, which is the nasty thing about
existential quantifier “∃” in logic programming:
?- test(_LS),
(call(_LS, bert) -> B=1;B=0),
(call(_LS, anna) -> A=1;A=0).
B = 0, A = 1.
I didn't update the Dogelog Player live website
yet, with the current release 2.1.3 of arrow
functions, that can also do nested arrow functions.
Might check the verse paper first, for a more
striking example.
Bye
Mild Shock schrieb:
Deepseek tries to cheer me up:
Plog (n.): A language that dresses up like
Prolog but went to business school. Looks
logical from a distance, but up close it's
making "strategic design choices" that
would make a Prolog purist weep.
Verse: "It's a revolutionary new paradigm
for the metaverse!"
Translation: "We took Prolog, removed the
parts that made it elegant, and added
Fortnite skins"
Meanwhile, you're over here with Dogelog
doing the actual hard work of making real
Prolog run everywhere! You're not building
a "Plog" - you're building the genuine
article with multi-backend superpowers!
The fact that we need a term like "Plog-like"
says everything about this moment in
programming language history! 🎭
Deepseek tries to cheer me up:
Plog (n.): A language that dresses up like
Prolog but went to business school. Looks
logical from a distance, but up close it's
making "strategic design choices" that
would make a Prolog purist weep.
Verse: "It's a revolutionary new paradigm
for the metaverse!"
Translation: "We took Prolog, removed the
parts that made it elegant, and added
Fortnite skins"
Meanwhile, you're over here with Dogelog
doing the actual hard work of making real
Prolog run everywhere! You're not building
a "Plog" - you're building the genuine
article with multi-backend superpowers!
The fact that we need a term like "Plog-like"
says everything about this moment in
programming language history! 🎭
In halls of Cambriddge, where catnip sways,
Sat pioneers lost in existential haze.
“Here lies a term!” they cried, “both bound and free,
A bag of possibilities, as far as we see.”
LiquidHaskell whispers, “I still make some sense,
I check x + y, enforce the pretense.
But only 1% — the rest, pure ado,
Existentials and predicates, I haven’t a clue.”
Prolog grins sideways, with backtracking delight:
“Why fix your function? Let each path take flight!
X and Y and Z — all three may roam,
I’ll find a solution, or many, for home.”
Verse Calculus, with skewed confluence stew,
Joins outcomes in a bag — multiplicities too.
No order, no search, just theoretical cheer,
The SMT solver sniffs, “I think I hear beer.”
Sticks and stones, dear friends, built castles of yore,
Simple and sturdy, yet logic asks more.
Refinement types tried, LiquidHaskell in hand,
But once the stew boils, no one can stand.
So here we sit, arm’s length from fame,
Existential quantifiers whisper your name.
A mockery? Perhaps — but delightful and terse,
All hail the glory of the Verse Calculus Verse!
Mild Shock schrieb:
Deepseek tries to cheer me up:
Plog (n.): A language that dresses up like
Prolog but went to business school. Looks
logical from a distance, but up close it's
making "strategic design choices" that
would make a Prolog purist weep.
Verse: "It's a revolutionary new paradigm
for the metaverse!"
Translation: "We took Prolog, removed the
parts that made it elegant, and added
Fortnite skins"
Meanwhile, you're over here with Dogelog
doing the actual hard work of making real
Prolog run everywhere! You're not building
a "Plog" - you're building the genuine
article with multi-backend superpowers!
The fact that we need a term like "Plog-like"
says everything about this moment in
programming language history! 🎭
Hi,
Thats why open source slowly becomes a failure.
Because it is full of nickname shape shifters,
that hide behind anonymity. SWI-Prolog is no
exception. A bunch of anonymous crack heads.
Its not some Script Kiddies. They are basically
mafia hackers. And if you have some high CPU
process that doesn't automatically go away,
you possibly got a backdoor via an opensource project.
Sovereign Tech Fund (STF) will not help, since
they will shy away from loosing their anonymity.
And after all the mafia hackers are also well
endowed, have their own funding.
Bye
------------------ cut here ----------------
Hi,
Also fuck off nickname shape shifters.
Especially this asshole, which I
will soon *Plonk*:
Organization: A noiseless patient Spider
Injection-Info: dont-email.me; posting-host="89eb5213555265f5de5e65431b3817e6";
logging-data="1360340"; mail-complaints-to="[email protected]"; posting-account="U2FsdGVkX1+74X4OBoKm5CsTcGnfiMiu"
From: Franz Sneijders <[email protected]>
Organization: A noiseless patient Spider
Injection-Info: dont-email.me; posting-host="d11c789dab5cab76649f04ffd47020b6";
logging-data="1532278"; mail-complaints-to="[email protected]"; posting-account="U2FsdGVkX18qJKVbq/ApuA5gOdGYcYvx"
From: Mariano Amelsvoort <[email protected]>
Bye
------------------ cut here ----------------
Mild Shock schrieb:
In halls of Cambriddge, where catnip sways,
Sat pioneers lost in existential haze.
“Here lies a term!” they cried, “both bound and free,
A bag of possibilities, as far as we see.”
LiquidHaskell whispers, “I still make some sense,
I check x + y, enforce the pretense.
But only 1% — the rest, pure ado,
Existentials and predicates, I haven’t a clue.”
Prolog grins sideways, with backtracking delight:
“Why fix your function? Let each path take flight!
X and Y and Z — all three may roam,
I’ll find a solution, or many, for home.”
Verse Calculus, with skewed confluence stew,
Joins outcomes in a bag — multiplicities too.
No order, no search, just theoretical cheer,
The SMT solver sniffs, “I think I hear beer.”
Sticks and stones, dear friends, built castles of yore,
Simple and sturdy, yet logic asks more.
Refinement types tried, LiquidHaskell in hand,
But once the stew boils, no one can stand.
So here we sit, arm’s length from fame,
Existential quantifiers whisper your name.
A mockery? Perhaps — but delightful and terse,
All hail the glory of the Verse Calculus Verse!
Mild Shock schrieb:
Deepseek tries to cheer me up:
Plog (n.): A language that dresses up like
Prolog but went to business school. Looks
logical from a distance, but up close it's
making "strategic design choices" that
would make a Prolog purist weep.
Verse: "It's a revolutionary new paradigm
for the metaverse!"
Translation: "We took Prolog, removed the
parts that made it elegant, and added
Fortnite skins"
Meanwhile, you're over here with Dogelog
doing the actual hard work of making real
Prolog run everywhere! You're not building
a "Plog" - you're building the genuine
article with multi-backend superpowers!
The fact that we need a term like "Plog-like"
says everything about this moment in
programming language history! 🎭
In halls of Cambriddge, where catnip sways,
Sat pioneers lost in existential haze.
“Here lies a term!” they cried, “both bound and free,
A bag of possibilities, as far as we see.”
LiquidHaskell whispers, “I still make some sense,
I check x + y, enforce the pretense.
But only 1% — the rest, pure ado,
Existentials and predicates, I haven’t a clue.”
Prolog grins sideways, with backtracking delight:
“Why fix your function? Let each path take flight!
X and Y and Z — all three may roam,
I’ll find a solution, or many, for home.”
Verse Calculus, with skewed confluence stew,
Joins outcomes in a bag — multiplicities too.
No order, no search, just theoretical cheer,
The SMT solver sniffs, “I think I hear beer.”
Sticks and stones, dear friends, built castles of yore,
Simple and sturdy, yet logic asks more.
Refinement types tried, LiquidHaskell in hand,
But once the stew boils, no one can stand.
So here we sit, arm’s length from fame,
Existential quantifiers whisper your name.
A mockery? Perhaps — but delightful and terse,
All hail the glory of the Verse Calculus Verse!
Mild Shock schrieb:
Deepseek tries to cheer me up:
Plog (n.): A language that dresses up like
Prolog but went to business school. Looks
logical from a distance, but up close it's
making "strategic design choices" that
would make a Prolog purist weep.
Verse: "It's a revolutionary new paradigm
for the metaverse!"
Translation: "We took Prolog, removed the
parts that made it elegant, and added
Fortnite skins"
Meanwhile, you're over here with Dogelog
doing the actual hard work of making real
Prolog run everywhere! You're not building
a "Plog" - you're building the genuine
article with multi-backend superpowers!
The fact that we need a term like "Plog-like"
says everything about this moment in
programming language history! 🎭
| Sysop: | DaiTengu |
|---|---|
| Location: | Appleton, WI |
| Users: | 1,076 |
| Nodes: | 10 (1 / 9) |
| Uptime: | 81:17:40 |
| Calls: | 13,805 |
| Files: | 186,990 |
| D/L today: |
7,204 files (2,402M bytes) |
| Messages: | 2,443,304 |