Dynamically typed languages are automobiles and statically
typed are bicyles?? Not exactly a neutral comparison and
hypocracy in light of his complaints against the strong
vs. weak labels.
[Obsessively tracking type information in dynamic
languages] prevents a programmer from realizing the
benefits of dynamic typing. It's like buying a new car,
but refusing to drive any faster than a bicycle. The car
is horrible; you can't get up the mountain trails, and it
requires gasoline on top of everything else. Indeed, a
car is a pretty lousy excuse for a bicycle! Similarly,
dynamically typed languages are pretty lousy excuses for
statically typed languages.
There's one particular thing about Christianity though.
Well OK, a couple of things, one it's kind of a modern
less complex flavor of Judaism, no offense meant to any
Hebrews reading this.
There are no French programming languages, not even Pascal
or Eiffel uses French words for the syntax, and all the
documentation is in English.
...we tested the role of SPW-Rs on memory consolidation.
Three groups of rats (test group, n = 7; stimulated
controls, n = 7; unimplanted controls, n = 12) were
trained to find food rewards ... .
During post-training rest and sleep, all of the online-
detected ripples were suppressed by commissural
stimulations in test rats (average online detection rate
was 86.0 ± 1.3% (s.e.m.) of post hoc detected SPW-Rs;
...). Stimulated control rats underwent the same
protocol, except that a random delay (80–120 ms)
was introduced between SPW-R detection and stimulation,
ensuring that the stimulations occurred mainly outside of
the ripple episodes.
Thus, these control rats received the same number of
stimulations as test rats, but their hippocampal
ripples were left largely intact. The global architecture
of sleep and the local field potential power in distinct
sleep stages were not modified by the suppression of
SPW-Rs ... . As stimulation outside SPW-Rs had
no detectable effect on task performance ..., the two
control groups were pooled and compared with test rats.
Performance of the test rats was significantly impaired
... .
The AST point is a subtle one. Classic Datalog (the thing that characterizes PTIME computation) doesn't have "constructors" like the ADTs (algebraic data types) we use in Formulog to define ASTs. Datalog doesn't even have records, like Soufflé. So instead you'll get facts like:
``` next_insn(i0, i1). insn_type(i0, alloc). alloc_size(i0, 8). insn_type(i1, move). insn_dest(i1, i0). insn_value(i1, 10). ```
to characterize instructions like:
``` %0 = alloc(8) %0 = 10 ```
I'm not sure if that's you mean by serializing relations. But having ASTs in your language is a boon: rather than having dozens of EDB relations to store information about your program, you can just say what it is:
``` next_insn(i0, i1). insn_is(i0, alloc(8)). insn_is(i1, move(i0, 10)). ```
As for your point about Prolog, it's a tricky thing: the interface between tools like compilers and the analyses they run is interesting, but not necessarily interesting enough to publish about. So folks just... don't work on that part, as far as I can tell. But I'm very curious about how to have an efficient EDB, what it looks like to send queries to an engine, and other modes of computation that might relax monotonicity (e.g., making multiple queries to a Datalog solver, where facts might start out true in one "round" of computation and then become false in a later "round"). Query-based compilers (e.g., https://ollef.github.io/blog/posts/query-based-compilers.htm...) could be a good place to connect the dots here, as could language servers.