On 2023-06-07, albert@cherry.(none) (albert) <albert@cherry> wrote:
> We are experiencing a surge in artificial intelligence.
> It is because of neural nets, not computer languages.
Probably since I was a child, I took it for granted that sufficiently
large neural networks will show intelligence: that it's just a number
crunching problem requiring the hardware to have lots of space (and
parallel computing power in order to work in anything resembling real
Not only that, but also that I will likely see this, or the start of it,
well within my lifetime. That dawn is here, pretty much.
I also already decided then that I wasn't interested in massive number
crunching, regardless of its results.
The intelligence that results from it can at most be about as
interesting as people. We've had people for millennia, and only
a few of them have been interesting, so ...
I like my computations to be nice and tight, using a small amount of
resources in order to produce a precise, repeatable result, whose
every aspect can be explained and traced to a piece of code, which
can be traced to a requirement.
> Groetjes Albert
You should open your mind more. Firstly, the MAL ("make a lisp") project
isn't a good way to learn about Lisp. It has a specific educational
goal and focus: to guide people through implementing Lisp-like
evaluation in any programming language, by following a certain recipe.
Production Lisps are not built according to such a recipe.
Quasiquation is something necessary and useful in Lisp because it's a
language which exhibits nested syntax. Just because you don't
have that in Forth doesn't mean it's nonsense. (Or that Forth is
nonsense due to not having that.)
MAL doesn't properly explain what quasiquotation is; it assumes you
know about it from somewhere else and just want to get it working
by following the steps in MAL.
Quotation allows a Lisp program to refer to a piece of its syntax
as a literal value. For instance whereas (+ 4 4) is an expression
that calculates 8, '(+ 4 4), which means exactly the same thing
as (quote (+ 4 4)) produces the value (+ 4 4): a list of three
elements, those being the + symbol, and the integer 4 appearing twice.
We can produce the same list in another way, for instance by
calling the list function with three arguments, which are evaluated
expressions: (list '+ 4 4). The symbol + is quoted, otherwise
it is treated as the variable + whose value is to be referenced.
The advantage of list is that we can stick in variable material,
(defun make-funny-list (arg)
(list arg 4 4))
Now we can call (make-funny-list 3) to produce (3 4 4),
or (make-funny-list '-) to produce (- 4 4).
Quasiquotation lets us use a visual template to do the same thing.
Instead of the quote, a different character is used, typically
(defun make-funny-list (arg)
`(,arg 4 4))
Everything in the backquote is literal-like constant material,
except for the parts indicated by the comma unquote, like ,arg.
Those expressions are evaluated and the value is inserted.
The quasiquote is a templating language for creating nested
lists using a notation which looks like those lists, rather
than hard-to-read nested constructor calls.
A quasiquote can be nested and it can insert material into
any level of nesting.
This templating notation is heavily used in writing macros,
and other code-to-code transformation situations.
Sometimes it is used in manipulating data which isn't code, too.
Manipulating syntax is an different approach to metaprogramming than
what is going on in Forth; you're only selling yourself short
if you dismiss that casually without learning anything about it.
(And then dismissing it, if you're still inclined.)
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal