<Josh_2>
How do I print to repl from a background thread?
robdog has joined #lisp
robdog_ has quit [Ping timeout: 252 seconds]
dale has quit [Quit: dale]
robdog has quit [Ping timeout: 252 seconds]
<Bike>
when you make the thread, make sure *standard-output* or whatever is bound to the value you want
robdog has joined #lisp
<Josh_2>
wait wat, I have *standard-output* in my format command which is the function called for the thread
<Josh_2>
I will check bt docs
<Bike>
when you make a thread it may not inherit some current bindings
FreeBirdLjj has joined #lisp
robdog_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
Tordek has quit [Ping timeout: 250 seconds]
robdog_ has quit [Ping timeout: 252 seconds]
terpri_ has quit [Remote host closed the connection]
Tordek has joined #lisp
mange has quit [Ping timeout: 246 seconds]
terpri has joined #lisp
<Josh_2>
Okay I did this: (acons '*standard-output* *standard-output* bt:*default-special-bindings*)
<Josh_2>
<Josh_2>
But no difference :O
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
<no-defun-allowed>
acons doesn't cause side effects
<Josh_2>
hmm, even so bt:*default-special-bindings* is the value of that acons form but still no output :O
<no-defun-allowed>
did you set the variable to the updated binding alist?
<Josh_2>
I think so (setf bt:*default-special-bindings* (acons '*standard-output* *standard-output*
<Josh_2>
bt:*default-special-bindings*))
robdog has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
buffergn0me has quit [Remote host closed the connection]
buffergn0me has joined #lisp
FreeBirdLjj has quit [Ping timeout: 255 seconds]
Ricchi has joined #lisp
Achylles has quit [Ping timeout: 252 seconds]
dddddd has quit [Remote host closed the connection]
robdog has joined #lisp
esrse has joined #lisp
Kundry_Wag has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
Kundry_Wag has quit [Ping timeout: 246 seconds]
SaganMan has quit [Ping timeout: 245 seconds]
igemnace has quit [Quit: WeeChat 2.4]
robdog has joined #lisp
CuriousCain has quit [Quit: WeeChat 2.2]
Ricchi has quit [Quit: Leaving]
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
SaganMan has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
lucasb has quit [Quit: Connection closed for inactivity]
polezaivsani has quit [Ping timeout: 246 seconds]
_whitelogger has joined #lisp
iovec has joined #lisp
dreamcompiler has joined #lisp
Necktwi has joined #lisp
vhost- has quit [Ping timeout: 246 seconds]
Kundry_Wag has joined #lisp
buhman has joined #lisp
Kundry_Wag has quit [Ping timeout: 246 seconds]
mindthelion has joined #lisp
techquila has quit [Read error: Connection reset by peer]
aindilis has quit [Remote host closed the connection]
aindilis has joined #lisp
Aruseus has quit [Remote host closed the connection]
notzmv has quit [Ping timeout: 255 seconds]
Arcaelyx has joined #lisp
torbo has left #lisp ["ERC (IRC client for Emacs 26.1)"]
vlatkoB has joined #lisp
Achylles has joined #lisp
zooey has quit [Ping timeout: 256 seconds]
akater has quit [Ping timeout: 256 seconds]
cantstanya has quit [Ping timeout: 256 seconds]
kushal has quit [Remote host closed the connection]
Bike has quit [Quit: Lost terminal]
zooey has joined #lisp
kushal has joined #lisp
akater has joined #lisp
quazimodo has joined #lisp
cantstanya has joined #lisp
aeth has quit [Ping timeout: 245 seconds]
aeth has joined #lisp
Kundry_Wag has joined #lisp
robdog has joined #lisp
slyrus__ has joined #lisp
slyrus_ has quit [Ping timeout: 245 seconds]
robdog_ has joined #lisp
Kundry_Wag has quit [Ping timeout: 272 seconds]
<buhman>
beach: that compact prefix tree search API suggestion you gave was really spot-on; I feel much better about this implementation.
robdog has quit [Ping timeout: 252 seconds]
<buhman>
it seems like I also need to return a 3rd bit of state: the prefix length
<buhman>
(values node suffix prefix-length)
<buhman>
this is to cover case where the leafmost node's label only partially matched the search string, so that -insert knows where to split that node
notzmv has joined #lisp
robdog_ has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
notzmv has quit [Remote host closed the connection]
notzmv has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
dreamcompiler has quit [Ping timeout: 245 seconds]
Kundry_Wag has joined #lisp
robdog has joined #lisp
Kundry_Wag has quit [Ping timeout: 250 seconds]
<beach>
Good morning everyone!
<beach>
buhman: Oh, great!
SaganMan has quit [Quit: WeeChat 1.6]
robdog has quit [Ping timeout: 252 seconds]
pierpal has quit [Remote host closed the connection]
<buhman>
^ for that insertion, -search would return the "test" leaf from the left. that leaf becomes the "st" leaf, and insert needs to create a new parent node, which becomes a child "te"
<buhman>
but -insert doesn't know what the parent of "test"-leaf is unless a parent relationship is modeled
<buhman>
am I thinking about this incorrectly?
<buhman>
for sibling insertion obviously parent is irrelevant, but the split insertion makes it seem like it's needed/more convenient
<beach>
I was thinking that if you want to insert "team" you return the root.
<beach>
and the entire string as suffix.
<buhman>
huh
<beach>
Perhaps the arc as well.
verisimilitude has joined #lisp
<beach>
I mean, you would return r 0 and the arc "test".
<beach>
Do you have explicit representations of the arcs?
<buhman>
no
<beach>
That might be a good idea.
<beach>
An arc would contain the label and its target node.
<beach>
That way, when you split an arc, you can modify the label and you don't have to mess with the origin node.
<buhman>
yeah, I was dreading all of the mutations that my current model would need
robdog has joined #lisp
<beach>
So in this case, you return r, 0 (meaning the start of the suffix i.e. entire string) and the arc with "test" in it.
<beach>
Then you compare the suffix of "team" starting at 0 (so all of "team") to "test" and you see that they have two letters in common.
<beach>
So you modify the label of the arc to say just "te", and you don't need to modify r.
<buhman>
I think your model "null tree" more naturally than my current model, which would need explicit handling for "false" or something
<beach>
Then you create two new nodes and two new arcs.
<buhman>
ok, this will take some hacking :)
<beach>
OK. I haven't really tried these ideas other than in my head, so there might be difficulties.
<beach>
But I don't anticipate any.
<beach>
If you REALLY want to, I can take some time today trying to implement this stuff.
<buhman>
nah, it's fine
<beach>
Oh, good, because I would rather work on my ELS talks.
<beach>
Also, I was thinking, if you have a very dense tree, using binary search to find an outgoing arc in a vector of arcs might be a good strategy.
robdog has quit [Ping timeout: 252 seconds]
<beach>
In fact, you can use change-class on the node and change the representation dynamically as the number of arcs grows.
<buhman>
so, each arc is sorted?
<beach>
And potentially use a different search strategy for different nodes.
<beach>
So the vector of outgoing arcs would be sorted then, yes.
<beach>
It would be worthwhile if you have relatively few insertions and a lot of lookups.
<buhman>
this was actually another concern I had; I was thinking about just sorting the vector by total-number-of-children/leaves, but binary search sounds better
<buhman>
yeah, actually my use-case is would theoretically allow for insertion to be compile-time macros
<beach>
I see.
<buhman>
so insertion can be maximum expensive if it makes sense
<beach>
Then I would definitely consider sorting the outgoing arcs of each node alphabetically in a vector..
<beach>
Do a binary search to find an outgoing arc.
<beach>
and return r, prefix-length, and the arc as above.
<buhman>
the binary search/sorting only cares about the current arc, and not any child arcs right?
<beach>
My thinking was that the binary search only cares about the current NODE in which a vector of arcs is stored. The elements of the vector would then be sorted alphabetically by the label.
<beach>
Like if you have a node with 20 children, then you would have a vector in that node with 20 elements, each element an arc.
<beach>
I don't know how you store the children at the moment.
robdog has joined #lisp
<beach>
I wouldn't worry about it for now. Just store the children as an unordered list until you get the algorithms right.
<buhman>
agreed
Jesin has quit [Quit: Leaving]
robdog has quit [Ping timeout: 252 seconds]
Jesin has joined #lisp
bilb_ono has joined #lisp
robdog has joined #lisp
<fiddlerwoaroof>
beach: did you have a write up about the common mistake you identified in binary search implementations?
Inline has quit [Quit: Leaving]
<fiddlerwoaroof>
(if it's you I'm remembering...)
robdog has quit [Ping timeout: 252 seconds]
orivej has joined #lisp
robdog has joined #lisp
jack_rabbit_ has quit [Quit: Leaving]
jack_rabbit_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
esrse has quit [Quit: ERC (IRC client for Emacs 25.3.1)]
Kundry_Wag has joined #lisp
esrse has joined #lisp
Kundry_Wag has quit [Ping timeout: 245 seconds]
bilb_ono has quit [Quit: bilb_ono]
bilb_ono has joined #lisp
frodef has joined #lisp
<beach>
fiddlerwoaroof: Not sure I made them that explicit, but I do have a section in my upcoming book about it. Let me check...
robdog has joined #lisp
orivej has quit [Ping timeout: 252 seconds]
nalkri has joined #lisp
<beach>
fiddlerwoaroof: I have no explicit text about the common mistakes. I should write a web page about it.
<beach>
There are basically 3 such mistakes:...
<beach>
1. Test for equality first, which doubles the number of comparisons.
bilb_ono has quit [Quit: bilb_ono]
<beach>
2. Use an element type that is too simple, like numbers, so that the complexity of key comparison is not obvious compared to comparing array indices.
makomo has joined #lisp
<beach>
3. Having one or more of the parameter in a global variable, like the vector or the element to look for.
quazimodo has quit [Ping timeout: 250 seconds]
robdog has quit [Ping timeout: 252 seconds]
<fiddlerwoaroof>
I think the first one I was thinking about
<beach>
Yeah, that's the worst offender.
<White_Flame>
I could see that. "early exit" optimization is actuallly anti-optimizing
Arcaelyx has quit [Read error: Connection reset by peer]
<beach>
Yes. When the object is not in the vector, the number of key comparisons is exactly double.
<White_Flame>
could you explain #2 a bit more? I don't quite understand what you mean there
<beach>
When the object *is* in the vector, on the average the number of key comparisons is something like 80% higher.
<fiddlerwoaroof>
Otherwise it's (1- double)?
<beach>
fiddlerwoaroof: It is more complicated, because it depends on which element you are looking for.
<beach>
So I computed the average by writing some code.
<fiddlerwoaroof>
interesting
Arcaelyx has joined #lisp
<beach>
White_Flame: Algorithms books tend to use integers as elements...
lavaflow_ has quit [Read error: Connection reset by peer]
<beach>
White_Flame: But nobody uses binary search for that, or they shouldn't.
<beach>
White_Flame: In reality you may have a vector of people, automobiles, labeled arcs, etc.
lavaflow_ has joined #lisp
<beach>
White_Flame: So, to compare two elements, you first have to get the key from the object and then compare the keys.
<beach>
From Common Lisp, we know that we need a :KEY and a :TEST parameter.
<beach>
Books just silently forget that.
<beach>
So the reader gets the impression that < can be used both for indices and elements.
<beach>
But the < for indices is a register comparison that can be done in half a clock cycle.
<beach>
The key comparison consists of two function calls and probably a loop comparing characters of a string.
<beach>
There is a 2 order of magnitude difference in the cost.
<beach>
If we use McCLIM for that software, we could have another "killer app".
keep_learning has quit [Remote host closed the connection]
robdog has joined #lisp
jprajzne has joined #lisp
Kundry_Wag has joined #lisp
didi has joined #lisp
<didi>
So, how evil is something like (defun fn (string &key (start 0) (end (length string))) ...). That is, establishing the END binding right on the parameter list?
<no-defun-allowed>
I think some sequence-handling functions do that already.
<pjb>
Why would that be evil?
<didi>
no-defun-allowed: Cool.
robdog has quit [Ping timeout: 252 seconds]
<didi>
pjb: I dunno.
<pjb>
didi: the problem is that :end nil means that, so you still have to test for nil and use (length string) in the body.
<didi>
Functions that have an END parameter doesn't seem to do it, so I suspected there was something there.
akoana has left #lisp ["Leaving"]
<beach>
didi: When the sequence can be a list, you don't want to traverse it initially.
<didi>
beach: True.
<beach>
didi: Imagine FIND where the element is close to the start, but the list is very long.
<didi>
That's a good argument.
<didi>
pjb: I think I see what you mean. A program might want to deal with a END value of NIL even if it has been passed by the user.
robdog has joined #lisp
igemnace has joined #lisp
dgi has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
gareppa has joined #lisp
akoana has joined #lisp
cranes has quit [Ping timeout: 246 seconds]
robdog has joined #lisp
gareppa has quit [Remote host closed the connection]
robdog has quit [Ping timeout: 252 seconds]
cranes has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
Kundry_Wag has joined #lisp
wigust has joined #lisp
wigust- has quit [Ping timeout: 268 seconds]
Kundry_Wag has quit [Ping timeout: 255 seconds]
Achylles has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
schweers has joined #lisp
krwq has left #lisp ["Killed buffer"]
varjag has joined #lisp
esrse has quit [Ping timeout: 268 seconds]
robdog has joined #lisp
Kundry_Wag has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
Fade has quit [Ping timeout: 264 seconds]
Kundry_Wag has quit [Ping timeout: 246 seconds]
rumbler31 has quit [Remote host closed the connection]
dddddd has joined #lisp
robdog has joined #lisp
quazimodo has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
quazimodo has quit [Ping timeout: 245 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
Selwyn has joined #lisp
orivej has joined #lisp
Ukari has quit [Remote host closed the connection]
<splittist>
Good morning #lisp
Ukari has joined #lisp
robdog has joined #lisp
Nomenclatura has joined #lisp
angavrilov has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
hhdave_ has joined #lisp
Nomenclatura has quit [Client Quit]
quazimodo has joined #lisp
<jcowan>
beach: There is also the classic bug of computing the new midpoint as (low+high)/2 instead of low + (high-low)/2 in languages without bignums.
<jcowan>
However, I don't see why using binary search for integers is a bad idea. In particular, the representation of (immutable) integer sets as a sorted list of endpoints of consecutive integers in the set is perfect for binary search. You search for an integer and then check the index to see if it's odd or even, which tells you if the integer is in or out of the set.
<shka__>
jcowan: naive binary search is pathological case for cache
<jcowan>
Yes, but so is following pointers in general. For best cache performance, write in Fortran.
<jcowan>
(in any language)
<pjb>
jcowan: it's a bad idea to teach sorting using sequences of integers, because comparing integers is the same complexity as comparing integers.
<pjb>
Compare that with sorting sequences of foo, where comparing foos is clearly a different complexity than comparing integers.
<jcowan>
I grasp that, pedagogically But beach asserted that nobody uses binary search over integers, or at least nobody should. That seems wrong.
<pjb>
Also, it's wrong to assume that memory access is O(1), because once you need to store your asymptotically big data on the next galaxy, the time to access it become very different.
<pjb>
Of course, sometimes you need to sort just integers.
robdog has joined #lisp
anewuser has joined #lisp
themsay has quit [Read error: Connection reset by peer]
iovec has quit [Quit: Connection closed for inactivity]
themsay has joined #lisp
<adlai>
i'm unaware of the full context for this topic, but if your integer sorting problems depend upon the specific encoding of the integers themselves, that's an implementation-specific issue.
<adlai>
you might be able to perform precise measurements within your implementation, but it's way out of the standard's scope.
rumbler31 has joined #lisp
<pjb>
adlai: the point is that when you compute the complexity, you should actually compute a vector, with one component for each type of operation, and comparing the indices must be distinguished from comparing the keys.
robdog has quit [Ping timeout: 252 seconds]
<jcowan>
pjb: Sorting data stored in Andromeda is *definitely* an application of external, not internal sorting.
<pjb>
Some people would memory map their galaxy storage!
* adlai
doubts that a vector is the correct datatype for a complexity class, since the different forms of complexity (time, space, etc) are not homogenous.
<pjb>
This is no problem. You can have inhomogenous bases.
<pjb>
For example, you can have time-coordinates and space-coordinates.
<pjb>
(x y z t).
andrei-n has joined #lisp
<jcowan>
I think it's pretty normal to exclude the element comparison from the complexity calculation, just as the claim that a particular hashtable implementation is O(1) implicitly assumes that the hash function is itself O(1).
<jcowan>
An earlier version of the Scheme hash table API required the hash function not to be O(1) in some cases, which pretty much broke hash tables. That's been changed.
<adlai>
pjb: surely you should respect the minkowski metric, and order that list differently!
<pjb>
Yes, but it doesn't matter.
<jcowan>
In particular, you are now allowed when hashing strings, lists, etc. to examine only a bounded number of elements.
Kundry_Wag has joined #lisp
<pjb>
jcowan: granted, your complexities must be given in function of the operations on the underlying data structures; which you have to instanciate to compute the actual complexities for a given data structure on a given machine.
rumbler31 has quit [Ping timeout: 240 seconds]
Fade has joined #lisp
robdog has joined #lisp
Kundry_Wag has quit [Ping timeout: 252 seconds]
<adlai>
pjb: thus, isn't a better structure for a complexity class one which has two levels of indirection, with operations costing time grouped separately from those costing space?
jbb has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
quazimodo has quit [Ping timeout: 246 seconds]
<pjb>
adlai: of course, you need to consider both time and space complexity. But the point is that you must express then not as a single O(.) expression, but as a vector of O(.) expressions in the basis of the algorithm underlying operations.
quazimodo has joined #lisp
jbb_ has quit [Ping timeout: 272 seconds]
<pjb>
Algorithms are expressed in terms of "basic" operations. But those operations don't have O(1) time or space costs. Each kind of basic operation can have a different cost from the other.
<pjb>
Most notably when you consider them asymptotically!
<pjb>
For example, you could still put a 6502 as an optimization core inside an intel processor. In the 6502, most operations are O(1), while on modern intel, the cost of operations is more varied, with cache, pipeline, speculative execution etc.
<adlai>
O-notations are a mathematical concept predating "computer science".
quazimodo has quit [Ping timeout: 250 seconds]
lavaflow_ has quit [Read error: Connection reset by peer]
<edgar-rft>
AFAIK O-notation appeared in 1894 while computer sciene already existed in antique egypt and greece.
* adlai
meant "computer science" as a department name printed on sheepskins handed to graduates of academic self-defense
robdog has joined #lisp
Kundry_Wag has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
iovec has joined #lisp
Kundry_Wag has quit [Ping timeout: 245 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
mrcom has quit [Quit: Leaving]
didi has quit [Ping timeout: 246 seconds]
mrcom has joined #lisp
flamebeard has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
Kundry_Wag has joined #lisp
robdog has joined #lisp
akr has joined #lisp
<akr>
I'm trying to use gitlab.common-lisp.net
Kundry_Wag has quit [Ping timeout: 252 seconds]
<akr>
why can I not open a merge request on a project? or is it just the setting of this specific project (cl-smtp)?
<akr>
can't fork either
dgi has quit [Ping timeout: 245 seconds]
robdog has quit [Ping timeout: 252 seconds]
lucasb has joined #lisp
robdog has joined #lisp
<pjb>
akr: probably because the owner of the project doesn't accept merge requests.
akoana has left #lisp ["Leaving"]
robdog has quit [Read error: Connection reset by peer]
pankajgodbole has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
Achylles has joined #lisp
Arcaelyx has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
polezaivsani has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 244 seconds]
robdog has joined #lisp
<akr>
pjb: alright thanks, I'll just open an issue then
lavaflow_ has quit [Ping timeout: 246 seconds]
quazimodo has quit [Ping timeout: 250 seconds]
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
keep_learning_M has joined #lisp
Kundry_Wag has joined #lisp
<beach>
jcowan: Sure, there might be some uses for it, but generally speaking, for sets, a hash table is much faster. And if the set contains small-ish integers, then a bit vector is faster.
<beach>
So the number of cases left for binary search is small.
<beach>
Same thing with trees.
<beach>
They are presented as being used for dictionaries, but hash tables are better for that.
<beach>
Trees are good for editable sequences though, but I never see them presented like that in the literature.
Kundry_Wag has quit [Ping timeout: 250 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
<jcowan>
Trees are also good for persistent maps, though HAMTs are a reasonable option.
<beach>
All I am saying is that the pedagogy of the books is usually wrong.
<beach>
The wrong data structures are used, and the implementations of the algorithms are often wrong.
<jcowan>
An integer (or character) set with many entries, however, is not well-served by a hash table. The difference between O(1) and O(log n) is typically unimportant in practice, except maybe in the inner loop, and the compression factor is often important.
<jcowan>
No argument with that! See _The Elements of Programming Style_.
<jcowan>
where all the bad examples come from textbooks.
<beach>
And by simplifying the domain to always be non-negative integers, they hide the real difficulties.
<jcowan>
For example, to implement Perl-compatble r.e.'s, you need to have over 100 sets of codepoints often organized as large blocks. A charset representing Chinese characters is just a few ranges, whereas as a hash table it would contain tens of thousands of entries.
<jcowan>
One of the problems I ask people on technical interviews has no solution if you assume, as almost everyone does, that the inputs are unbounded-size integers.
<beach>
And if I saw regular expressions with Chinese characters as the main example in the books when they discuss binary search, I would not protest.
<dim>
I would ask if the concept of a regular expression has any meaning in Chinese writing, though
<pjb>
Why not?
<dim>
(because all I know about Chinese writing system is that it's completely different from anything I've tried to grasp before)
<beach>
I am willing to bet that no example of binary search in any of the books has an integer less than 0 or greater than 100.
<pjb>
Just as meaning as the regexps used in eliza.
<dim>
my understanding is the Chinese writing system doesn't use letters or an alphabet, so why would regexp have any meaning there?
<dim>
anyway, it's side tracking the conversation, sorry
<pjb>
("you think (.*)" "why do you say I think \\1")
<pjb>
（"你认为(.*)" "为什么你说我认为\\1"）
robdog has joined #lisp
<jcowan>
And in particular /\P{Han}/ matches any string with at least one Chinese character in it (which might activate some special processing)
<pjb>
So you can match “你觉得我很蠢” and return "为什么你说我认为我很蠢" which translates correctly to "Why do you say that I think I am stupid?"
<pjb>
(the semantic error comes from the error in the regexp, of course. eliza has correct rules which match and transform correctly the pronouns)
<jcowan>
Fortunately in Chinese "obvious" verb arguments can be left out
<jcowan>
"Did you hear <something>?" "Heard."
<shka__>
what a fascinating topic
<jcowan>
Broadly speaking: alphabetic systems have one letter per significant sound (with many exceptions), Chinese writing has one character per {sound, meaning} pair (with many exceptions).
<pjb>
That said, like you wouldn't implement a compiler using just regexp, you wouldn't implement a serious NLP using just regexps. You need parsing to do it correctly.
<jcowan>
Sure.
<jcowan>
which is why people who try to parse HTML with regexps will BURNINATE IN HELL
robdog_ has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
<adlai>
jcowan: what do you mean by the abbreviation "HAMT"?
keep_learning_M has quit [Quit: This computer has gone to sleep]
<adlai>
this is actually quite wonderful... aeons ago, when I wrote my first automated trading system, I recognized a bunch of 'problems' which I hadn't studied enough to solve instinctively; and this datastructure may help me, when I next attack that problem.
<adlai>
the specific problem in question being that of an adjustable histogram for caching the offers advertised by an exchange.
gxt has joined #lisp
robdog has joined #lisp
q9929t has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
gxt has quit [Ping timeout: 244 seconds]
Essadon has joined #lisp
Essadon has quit [Max SendQ exceeded]
robdog has joined #lisp
<shka__>
adlai: i have implementation of HAMT based dictionary in the cl-data-structures
ggole has joined #lisp
<shka__>
and yeah, it is pretty neat data structure
<adlai>
shka__: the case which is relevant to automated trading is likely to require that I implement a specific datastructure myself, since offers in exchanges (whether spot, or derivatives) have distributions seldom encountered outside of finance.
<adlai>
(much blood and tears have mingled over the overly rapid optimization of such data)
<shka__>
hm, ok
<adlai>
however, thank you for pointing out your implementation. I may refer to it when I return to this problem! :)
ym555 has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
gareppa has joined #lisp
robdog has joined #lisp
<shka__>
adlai: data structures are my hobby, and data science is my job, i would be pleased to discuss those unusual distributions in the finacial data you mentioned once you run in any issue
Achylles has quit [Quit: Leaving]
robdog has quit [Ping timeout: 240 seconds]
ggole- has joined #lisp
ggole has quit [Ping timeout: 240 seconds]
<jcowan>
Funny how data science is nowadays done with only the simplest data structures. Still, they are the fastest (see above re: Fortran).
ggole_ has joined #lisp
<shka__>
eh, this is very unfortunate if you ask me
ggole- has quit [Ping timeout: 268 seconds]
igemnace has quit [Quit: WeeChat 2.4]
Necktwi has quit [Remote host closed the connection]
robdog has joined #lisp
ggole_ has quit [Ping timeout: 240 seconds]
random-nick has joined #lisp
robdog_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog_ has quit [Ping timeout: 252 seconds]
Arcaelyx has joined #lisp
Bike has joined #lisp
rumbler31 has joined #lisp
rlp10 has joined #lisp
robdog has joined #lisp
heisig has joined #lisp
rumbler31 has quit [Ping timeout: 245 seconds]
robdog has quit [Ping timeout: 252 seconds]
LiamH has joined #lisp
warweasle has joined #lisp
wxie has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 255 seconds]
jva has joined #lisp
robdog has joined #lisp
<dtw>
Is it ok to use restart name CONTINUE which is actually symbol from CL package? It works fine but I haven't used restarts that much so I would like to get more educated views.
<Xach>
dtw: it is ok
<Xach>
dtw: same with abort
<Xach>
hmm, but that's not what 11.1.2.1.2 says. so i have to rethink that answer.
scymtym has joined #lisp
jva has quit [Quit: leaving]
<dtw>
Thanks. You are probably looking at the list item "18. Binding it as a restart name. "
<Xach>
no, i am looking at irc, but earlier i was looking at that!
<Bike>
with-simple-restart examples have it binding ABORT. examples aren't normative, but i think that's a pretty normal thing to do, so maybe the package restriction there is a little overzealous.
<jdz>
What would be the difference of using CERROR and RESTART-CASE manually?
robdog has quit [Ping timeout: 252 seconds]
<Xach>
i know i have used abort and continue myself, and i have not been struck dead from above, but conformance is itself the main virtue, so
<jdz>
I've also been using CL:CONTINUE till now.
sjl_ has quit [Quit: WeeChat 2.3-dev]
<Bike>
it's also kind of weird since i don't think there's any reason not to bind these things
<Bike>
is anything in the standard actually required to bind an abort restart?
<dtw>
Perhaps I should change my restart names (or shadow CL's).
sjl_ has joined #lisp
<Bike>
continue is from cerror, and use-value is in assert or something
<jdz>
One would really have to go out of their way to not use CL:CONTINUE or CL:ABORT as a restart name.
<Bike>
the clhs page for abort says the repl establishes it, so presumably the repl doesn't count as a conforming program
rippa has joined #lisp
q9929t has quit [Quit: q9929t]
Fade has quit [Quit: leaving]
<_death>
the clhs page for continue says "Some user-defined protocols may also wish to incorporate it for similar reasons. In general, however, it is more reliable to design a special purpose restart with a name that more directly suits the particular application." and "incorporate" may or may not include binding
<Bike>
i just... don't see any reason to forbid binding restarts? even if you have a cerror and you want to use that cerror's restart, you can just pass the CONTINUE function the continuable error, and it'll get the right restart even if there are intermediate bindings
wxie has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
Fade has joined #lisp
Kundry_Wag has joined #lisp
gareppa has quit [Quit: Leaving]
notzmv has quit [Ping timeout: 246 seconds]
robdog has quit [Ping timeout: 252 seconds]
keep_learning_M has quit [Quit: This computer has gone to sleep]
anamorphic has joined #lisp
dale_ has joined #lisp
dale_ is now known as dale
anamorphic has quit [Client Quit]
anamorphic has joined #lisp
<jcowan>
I think it is bad practice to use ABORT, USE-VALUE, etc. in ways that have nothing to do with their normal usage, but certainly binding them is totally legitimate: you may be running your own non-Lisp REPL and want ABORT to abort to your REPL rather than the Lisp REPL.
robdog has joined #lisp
pierpal has joined #lisp
robdog has quit [Ping timeout: 258 seconds]
lavaflow_ has joined #lisp
sjl_ has quit [Quit: WeeChat 2.3-dev]
sjl_ has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
bobby has quit [Ping timeout: 252 seconds]
robdog has quit [Ping timeout: 252 seconds]
anamorphic has quit [Quit: anamorphic]
anamorphic has joined #lisp
robdog has joined #lisp
charh has quit [Ping timeout: 272 seconds]
Josh_2 has quit [Ping timeout: 268 seconds]
SpikeMaster has joined #lisp
gareppa has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
SpikeMaster has quit [Quit: ERC (IRC client for Emacs 27.0.50)]
charh has joined #lisp
shka__ has quit [Quit: WeeChat 1.9.1]
robdog has joined #lisp
jack_rabbit_ has quit [Ping timeout: 252 seconds]
gareppa has quit [Quit: Leaving]
robdog has quit [Ping timeout: 252 seconds]
gareppa has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
anewuser has quit [Quit: anewuser]
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
bobby has joined #lisp
ym555 has quit [Quit: leaving...]
robdog has joined #lisp
heisig has quit [Remote host closed the connection]
charh has quit [Ping timeout: 246 seconds]
jprajzne has quit [Remote host closed the connection]
robdog has quit [Ping timeout: 252 seconds]
bobby has quit [Ping timeout: 252 seconds]
charh has joined #lisp
robdog has joined #lisp
bobby has joined #lisp
ym555 has joined #lisp
robdog_ has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
robdog_ has quit [Ping timeout: 252 seconds]
Arcaelyx has quit [Ping timeout: 240 seconds]
CuriousCain has quit [Quit: WeeChat 2.2]
Inline has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
klltkr has quit [Ping timeout: 258 seconds]
Essadon has joined #lisp
robdog has joined #lisp
igemnace has joined #lisp
osune has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
ym555 has quit [Ping timeout: 250 seconds]
flamebeard has quit []
robdog has joined #lisp
schweers has quit [Ping timeout: 252 seconds]
scottj has joined #lisp
shka_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
CuriousCain has joined #lisp
ebrasca has joined #lisp
Kundry_Wag has joined #lisp
norserob_ has joined #lisp
norserob_ has left #lisp [#lisp]
robdog has joined #lisp
norserob_ has joined #lisp
norserob_ has left #lisp [#lisp]
<beach>
jackdaniel: I have one more question about the ECL build process if you have a minute.
orivej has quit [Ping timeout: 244 seconds]
<beach>
jackdaniel: At which point are the data structures for standard generic functions built, like the list of methods, the call cache, the effective method function, etc.?
<jackdaniel>
go ahead
<beach>
jackdaniel: Are they already built in the object code generated by the compiler?
<beach>
... or is it done when ecl starts up the way it is done in Clasp?
robdog has quit [Ping timeout: 252 seconds]
<beach>
I can't imagine it is done at startup time; as I understand ECL starts up very fast.
<jackdaniel>
gf dispatch is implemented in C module (there is one function performing that), so it is part of ecl_min. structures are filled when ecl starts
<beach>
Oh!
karlosz has joined #lisp
<beach>
Interesting.
<beach>
Thanks!
<jackdaniel>
generic functions are not compiled (as of 2019)
<jackdaniel>
of course method bodies are compiled
<beach>
I see.
Kundry_Wag has quit [Remote host closed the connection]
<jackdaniel>
improving this state of affair will come after 16.2.0 release (dispatch is the biggest bottleneck when compared to other implementations)
<beach>
So I guess the code that generates the data structures is in one of those sections of the ELF file, like CTOR or whatever it is called?
karlosz has quit [Client Quit]
eddof13 has joined #lisp
<jackdaniel>
I'm not sure if I understand the question, but if I do then this is false, as I said generic functions are not compiled and these things are populated at runtime
robdog has joined #lisp
<beach>
You said "when ecl starts", and one way of doing that is to stick that code in the relevant section in the ELF executable. That's how C++ executes constructors that must be executed before main() starts.
<beach>
But it doesn't have to be done that way of course.
anamorphic has quit [Quit: anamorphic]
<beach>
It could be done with explicit code called from main().
<beach>
But the difference is not important at this point for my understanding. Thanks again.
karlosz has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
<jackdaniel>
no problem
robdog has joined #lisp
sauvin has quit [Read error: Connection reset by peer]
robdog has quit [Ping timeout: 252 seconds]
nanoz has joined #lisp
anamorphic has joined #lisp
ym555 has joined #lisp
hhdave_ has quit [Ping timeout: 250 seconds]
Kundry_Wag has joined #lisp
Jesin has quit [Quit: Leaving]
robdog has joined #lisp
Jesin has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
nowhere_man has joined #lisp
lumm has joined #lisp
karlosz has quit [Quit: karlosz]
anamorphic has quit [Quit: anamorphic]
nowhere_man has quit [Ping timeout: 258 seconds]
anamorphic has joined #lisp
pankajgodbole has quit [Ping timeout: 252 seconds]
gareppa has quit [Quit: Leaving]
bendersteed has joined #lisp
orivej has joined #lisp
Fare has joined #lisp
Necktwi has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
MightyJoe is now known as cyraxjoe
nanoz has quit [Ping timeout: 245 seconds]
robdog has joined #lisp
zooey has quit [Ping timeout: 256 seconds]
Bike_ has joined #lisp
Bike has quit [Disconnected by services]
Bike_ is now known as Bike
robdog has quit [Ping timeout: 252 seconds]
zooey has joined #lisp
anamorphic has quit [Quit: anamorphic]
Selwyn has joined #lisp
robdog has joined #lisp
ebrasca has quit [Remote host closed the connection]
robdog has quit [Ping timeout: 252 seconds]
Kundry_Wag has joined #lisp
okeg has joined #lisp
makomo has quit [Quit: WeeChat 2.2]
Josh_2 has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
Aruseus has joined #lisp
Khisanth has quit [Ping timeout: 246 seconds]
frodef has quit [Ping timeout: 245 seconds]
anamorphic has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
Khisanth has joined #lisp
warweasle has quit [Quit: later]
robdog has joined #lisp
bilb_ono has joined #lisp
robdog_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog_ has quit [Ping timeout: 252 seconds]
anamorphic has quit [Quit: anamorphic]
anamorphic has joined #lisp
robdog has joined #lisp
Arcaelyx has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
<jcowan>
Is it typical for Lisp implementations to optimize SLOT-VALUE with a constant slot name, or do people normally avoid SLOT-VALUE unless they really need to deal with a slot specified at run time?
<sjl_>
I almost always define accessors. They're easier to change backwards compatibly in the future, you don't have to alexandria:curry to mapcar them, etc
<sjl_>
s/define/tell defclass to define/
<Bike>
it's kind of hard to optimize slot-value in the face of optimizations
<aeth>
jcowan: afaik, last time this came up the counter-intuitive conclusion is that accessors can be more efficient than slot-value (so always use WITH-ACCESSORS/accessors over WITH-SLOTS/SLOT-VALUE). beach probably knows the details.
<jcowan>
Why counterintuitive? Makes total sense to me.
<Bike>
it's counterintuitive if you think slot-value is "lower level" or something
<aeth>
I think a lot of people do with-slots for "efficiency". Probably a beginner trap in using the language.
<jcowan>
I think of it as reflective whereas accessors are non-reflective.
<jcowan>
(and therefore reflectors are lower level)
<jcowan>
But converting (slot-value foo 'bar) into (bar-accessor foo) is something a compiler macro should be able to do, I'd think.
<jcowan>
s/reflectors/accessors/, of course
<Bike>
the class has to be defined at compile time and you have to know that it won't be redefined incompatibly in the mean time.
* jcowan
nods.
<Bike>
on sbcl there are apparently stereotypically named accessors entirely to avoid that
<Bike>
if i'm reading correctly
<aeth>
I avoid slots everywhere. When you do this, you have to use an idiom like (... :accessor %foo :reader foo) where %foo isn't exported when you want a fake "read-only" slot in a defclass, which is a fairly counter-intuitive idiom, too. You could just have a separate writer, but if the name differs from the reader, it won't work well with WITH-ACCESSORS, so essentially this idiom happens.
<aeth>
I think people not wanting to do something like the above trick above is the main use of slot-value.
<jcowan>
That idiom is completely standard in Scheme.
<jcowan>
(well, the version with a separate writer, because Scheme has no SETF as yet)
themsay has quit [Ping timeout: 240 seconds]
themsay has joined #lisp
scymtym has quit [Ping timeout: 252 seconds]
<aeth>
Well, standard Scheme doesn't.
<Bike>
i think it can reasonably assumed that when jcowan says "scheme" that is what's meant
* jcowan
nods
<jcowan>
It is on the docket, and if it passes something may need to be added to the equivalent of defstruct.
<Demosthenex>
jmercouris: i've been hunting a decent tui lib for ages.... in fact i just completed a proof of concept crud interface in go tonight because tview looked awesome, i just can't stand the go language ;]
<verisimilitude>
Yes.
<jmercouris>
in go? why didn't you ask on the channel before comitting such a sacrilege?
<Demosthenex>
jmercouris: i have asked. i've been looking at tui's for... ages. months? years? channel's been very generous
<Demosthenex>
but they can't make up for the lack of interest in tuis and the aging libs out there
<Demosthenex>
and a simple character interface != widget libs and form drivers.
<jmercouris>
verisimilitude: it is pretty low level, do you have an accompanying widget library you made on top?
<jmercouris>
not looking for anything crazy, just a list view, and a text box view
<jmercouris>
I guess I could make them
<Demosthenex>
jmercouris: croatoan
<Demosthenex>
is the best i've seen so far, in my nooby opinion
karlosz has quit [Quit: karlosz]
shka_ has quit [Ping timeout: 245 seconds]
<verisimilitude>
No; I only provided an abstraction. I didn't want to provide a ``look'' for it.
<jmercouris>
Demosthenex: interesting
bilb_ono has joined #lisp
<jmercouris>
verisimilitude: so what makes your program different than others? you don't use any CFFI?
<jmercouris>
is that what I am understanding?
<verisimilitude>
It's actually Common Lisp, instead of C.
<jmercouris>
yeah, that's what I said more or less, no?
<verisimilitude>
Yes.
<jmercouris>
Interesting, maybe I'll make a few widgets on top of it
<jmercouris>
wow a single .lisp file as the source!
<jmercouris>
doesn't get lighter than that
<jmercouris>
Why did you give it this license, man, I cannot use this
robdog has joined #lisp
<verisimilitude>
I understand _death is doing something with it you may be interested with.
<jmercouris>
would you consider relicensing it under a BSD or MIT license?
<verisimilitude>
No.
<jmercouris>
Why not?
<verisimilitude>
I don't want it to be used in proprietary software.
<jmercouris>
That's not the point, I make Next BSD licensed, because that is true freedom
<verisimilitude>
That's my reason is all.
<jmercouris>
GPL can still be used in proprietary software no problem
buffergn0me has quit [Read error: Connection reset by peer]
buffergn0me has joined #lisp
<jmercouris>
especially if I just build on top of your lib and don't make any changes to your source, I have no requirements to give you source upstream
<aeth>
GPL absolutely can be used in proprietary software. Even AGPL. Thank the cloud for that.
<verisimilitude>
Sure; it's only with those you give it.
<jmercouris>
I am not particularly thankful for the cloud :D
<aeth>
That message has been logged.
<jmercouris>
I used to not be so polarized on this issue, but lately I try very hard not to use any GPL licensed software
<jmercouris>
#skynet
<verisimilitude>
If I like the (A)GPLv4, it will be upgraded.
robdog has quit [Ping timeout: 252 seconds]
<jmercouris>
I just don't understand, what is there to like about the GPL? if it feels like software communism
<Demosthenex>
i was looking at using abcl to access jexer. but... java ;]
<aeth>
Well, you can maximize users or you can use a license like AGPL. I prefer maximizing users because I use a niche language, although I understand others don't want that.
<jgkamat>
jmercouris: I've seen one too many projects I use go non-free, so thats why I try to only use/write gpl software
karlosz has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
<jmercouris>
jgkamat: Even if they *did* use GPL, they could do a clean room implementation of a small bit and easily make a closed fork
<verisimilitude>
Why work for free to save someone else money using my software in a proprietary produuct?
<jmercouris>
GPL is an illusion of protection, but is in actuality highly restrictive and controlling
<jgkamat>
don't think they can do that, they would need to rewrite the whole thing
<jmercouris>
what does this have to do with proprietary products?
<jmercouris>
no, they wouldn't actually
<jmercouris>
they would only need to do a clean rewrite of whatever contributions did not hand over rights
<jcowan>
Generalizations are always a bad idea, as they invariably lead to bad reasoning.
<jmercouris>
and usually in a big project, only a very small percentage of software comes from outside contributors
<jgkamat>
yah, that's also why I don't like signing CLAs
<jmercouris>
I spent a lot of time on the GPL side of the fence, probably around 6 years, but lately I see that there is only true freedom in BSD
<jmercouris>
usually a minority position in the FOSS community, but I see a lot of Lisp Code is MIT or BSD licensed
<jcowan>
BSD vel sim. licensors are generous givers; GPL licensors are generous sharers.
<jcowan>
So what license you use depends on your purposes.
<jmercouris>
I would disagree, GPL licensors tell you how to live your life and what you are allowed to do and not do
<jmercouris>
they are pushing a philosophy, saying, you must do things *my way*, because *I'm right*
<verisimilitude>
Well, it's not going to become more permissive, jmercouris.
<jgkamat>
either way, most of the time when I see a permissive license software with bugs/broken features, I rewrite it only after changing the license
<verisimilitude>
Ideally, we wouldn't have copyright.
<jmercouris>
Ideally we wouldn't have copyright? Hmm, that's a very difficult argument
<jgkamat>
the point is I don't ever want things with 'my copyright' to be non-free
frodef has joined #lisp
<jmercouris>
That's absolutely why they should be BSD licensed
<jmercouris>
the GPL is anti-freedom
<jcowan>
Some GPL licensors are pushing a philosophy, some use the GPL for commercial advantage, some don't want their code used to make money when they get none of it. It varies.
<jgkamat>
I don't think so, BSD is perfect for patent trolls
<jmercouris>
I give, without strings attached
<aeth>
Proprietary projects absolutely have the budget to clean room reverse engineer your AGPL library if they want equivalent functionality. Lots of AGPL projects skip that step and sell a proprietary version in addition to their AGPL version. Who gets left out are the people in the middle, writing FOSS with AGPL-incompatible licenses.
<jcowan>
The GPL favors the freedom of the user at the expense of the freedom of the developer.
<jmercouris>
jgkamat: could you elaborate on how BSD is used by patent trolls?
<jgkamat>
jmercouris: it dosen't provide a waiver of patent rights like the gpl does
<jcowan>
Give away the code, sue you for breaching their patents when you use it.
<jgkamat>
so you could run into patent issues down the road and/or get sued through that mode
<verisimilitude>
Ideally, if someone ``stole'' your source code, you wouldn't be able to do anything about it.
<jmercouris>
jgkamat: you can't just patent something if there is prior invention, so that is not true
<jmercouris>
all you have to do to invalidate their patent is show prior art
<la_mettrie>
laws that forbid us to take other people as prisoners restrict our freedom but increase the level of freedom in the society. GPL is similar.
<jmercouris>
and if they patent what you did, that is literally the prior art
<jgkamat>
you can tell that to oracle then, not me :]
<jcowan>
But the presumption is in favor of the patent writer
<jmercouris>
jgkamat: Oracle is a disease, with a lot of money, what they have is power, what they do is illegal
<jmercouris>
then again, whoever has the bigger stick is what is legal anyways...
<jgkamat>
no - it is legal, hence their wins in the supreme court
<jgkamat>
er, not supreme but whatever
<zigpaw>
there was this talk on youtube on patent exhaustion.
<jmercouris>
If you are talking about Java, Oracle was correct to win the case
<jcowan>
If you want to worry about something, worry about Oracle v Google, not the details of OSS licenses
<aeth>
Imo, if you want to restrict commercial use and you're writing an end-user application, a better approach than GPL is to control the assets. This works better for things like games, but it's not impossible in other areas. e.g. Firefox has restrictive enough trademark restrictions that Debian had "Iceweasel" for a long time.
<jmercouris>
la_mettrie: that's not a valid comparison, BSD doesn't increase an individuals freedom to the detriment of others
<jcowan>
If you combine the abstraction-comparison-filtration test with the copyrightability of APIs, you have created a situation in which work-alikes are almost impossible.
<verisimilitude>
As it stands, I have the only good and reasonably comprehensive terminal libraries that aren't just Ncurses wrappers. You're free to use the inferior Ncurses solution and risk memory leaks in a Lisp program to manage a terminal, though.
<jcowan>
Comprehensive = many terminals, or many functions?
<jmercouris>
verisimilitude: As much as I would like to use your software and could, and there is nothing preventing me from making a widget library atop yours, I would rewrite it out of principle
<la_mettrie>
jmercouris: yes it does because it makes it possible for individuals to close the code
<zigpaw>
the above video is about "The surprising interaction of open source and patent exhaustion" from latest Fosdem 2019, I think worth watching.
<aeth>
verisimilitude: As it stands right now. You just created a good incentive for someone to create a CC0 library out of spite.
<verisimilitude>
I just mean it's more than a few incomplete functions, jcowan.
<jcowan>
Okay.
<jmercouris>
la_mettrie: it allows them to make improvements and close the code, that is their own effort, they have the *right* to close the code should they so choose to
<jgkamat>
and the right to sue you, which is nice to have too I suppose
<verisimilitude>
My SHUT-IT-DOWN library is CC0, because I didn't care what people do with it and wanted to encourage others, without license worries.
<jcowan>
jmercouris: You couldn't rewrite it, because verisimilitude could sue you for API infringement. You'd have to do it completely clean-room.
<aeth>
Libraries aren't special unless you're doing some really niche advanced machine learning that requires a PhD to write it or something. Your AGPL library *is* going to be cloned if anyone cares. If it's being cloned for use in proprietary software, that clone might not even be shared with anyone else.
<jmercouris>
jcowan: yeah, sure, but I could make the claim of prior art because he copies the curses API
<jmercouris>
it's not implemented in C, but I recognized a few function names in there :D
<jcowan>
prior art is relevant to patents, not copyrights.
<jmercouris>
yeah sure, I said a rewrite did I not?
<verisimilitude>
Oh, I didn't, jmercouris.
<jcowan>
Probably no one is in a position to sue over the curses API (particularly since it's part of Posix)
<verisimilitude>
I don't know the Ncurses API.
<verisimilitude>
It's entirely my own design.
<jgkamat>
and even then, every patent has prior art, you can't just claim prior art on all patents
<aeth>
jmercouris: That's why I immediately close the tab as soon as I see the license is AGPL, GPL, LLGPL, etc. I am going to be extra careful because in case I ever need similar functionality I'm going to have to write it myself.
<jmercouris>
Well, your own design, is surprisingly similar to the actual curses library
<jmercouris>
aeth: I am with you 100%, I'm not in the business of being told what I can and cannot do
<aeth>
I know nothing about the internals of AGPL, GPL, and LLGPL Common Lisp libraries.
la_mettrie has left #lisp ["WeeChat 2.2"]
<jmercouris>
jgkamat: I think you may be misinformed, if prior art exists, the patent office does not grant a patent! that is why there is an exhaustive search
<jmercouris>
you can read all sorts of famous/funny cases about that exact scenario
<verisimilitude>
I'd like to see more Common Lisp libraries that aren't just CFFI wrappers. When I write them in pure or reasonably pure Common Lisp, they're going to be AGPLv3, if not a later license. I don't see why a useful library not being permissively licensed is so offensive.
<jmercouris>
for example, someone wanted to patent lifting boats out of the bottom of the ocean by ffilling them with ping pong balls, but the patent was denied because it appeared in a donald duck cartoon
<jgkamat>
jmercouris: I have a friend who works issuing patents who says the exact opposite. Either way, if prior art invalidated patents, you could make the argument that all patents are invalid.
<jmercouris>
in fact, in Germany, what many people due to avoid their work patented is publish a small book that they distribute to a few libraries that includes the art so that it *cannot* be patented
<jgkamat>
so use a license which waives patent rights?
<aeth>
verisimilitude: A useful library licensed under the AGPL might as well not exist.
<verisimilitude>
Well, maybe one day I'll have so many useful libraries built up that you won't be able to write that, aeth.
<jmercouris>
verisimilitude: well, its 2v1, so we'll outwrite you :D
<aeth>
Writing a Common Lisp library that's AGPL is like writing a library that only runs under Aeth Common Lisp. Most Common Lispers will just move on and find something else or write their own.
<verisimilitude>
In all this time, I'm the only person who bothered to write a rather comprehensive library instead of leaning on Ncurses, so I'm not worried.
<aeth>
It's because there's no interest in that area at this time.
<jmercouris>
well, there isn't exactly a huge demand...
Kundry_Wag has quit [Remote host closed the connection]
<aeth>
As soon as there's a demand, someone will look for libraries, find yours, look at the license, close the tab, and write their own.
<aeth>
And now we have 2 libraries.
<jgkamat>
isn't that a good thing though?
<verisimilitude>
Currently, I'm working on Gopher protocol tools in Common Lisp, which is something else I've seen nothing of; that will also be AGPLv3.
<aeth>
Gopher, another thing there's not much demand for.
<jmercouris>
verisimilitude: I would strongly urge you to re-evaluate the licenses and rethink it
<verisimilitude>
There's some interest, apparently, since jmercouris wanted me to relicense it.
bilb_ono has quit [Quit: bilb_ono]
<jmercouris>
Its not like I plan on making a killer TUI program, and becoming a millionaire off off it leaving you in the dust :D
<verisimilitude>
More libraries is a good thing, aeth.
<jmercouris>
Not if they can't be used
Kundry_Wag has joined #lisp
<jmercouris>
Lisp is particularly problematic with multilicensed libs because of how it compiles
ravenousmoose has joined #lisp
<jmercouris>
the GPL even released a special lisp specific lib
<jmercouris>
so the moment you bring in one of these libraries, your whole program is infected
<aeth>
verisimilitude: The problem with Common Lisp is that everyone has their own library that implements, usually without documentation, 80% of something. A different 80% for each library, and often very styllistically different from each other.
<jmercouris>
s/lib/license
<verisimilitude>
Well, my libraries are all well-documented, aeth.
<aeth>
Every now and then you see a collaboration between two people.
<jgkamat>
that's very true, usually when I find a library I end up rewriting it anyway because it's not good enough
<aeth>
jmercouris: The point of an AGPL library (rather than application) *is* to infect your entire program. It's inherently political.
Kundry_Wag has quit [Remote host closed the connection]
<jmercouris>
which is exactly my problem with it
<aeth>
jgkamat: Exactly.
<aeth>
I have fairly unique performance requirements so I wind up not using many libraries.
<jmercouris>
jgkamat: I think my stuff is pretty well documented :D
<jgkamat>
I found next to be a mess from what I looked at fwiw, but thats just my opinion
<jgkamat>
documentation is nice, but the code didn't make much sense to me
<aeth>
I wrote maybe the 10th defun wrapper that exists (define-function) because all of the existing ones were a mess (and half of them were also a licensing mess)
<jmercouris>
Well, it is a non trivial program...
karlosz has quit [Quit: karlosz]
<jmercouris>
jgkamat: what part of it is a mess, exactly?
<verisimilitude>
I see this push to be ``nice'' and use permissive licenses to be mostly for the benefit of large companies that want free work. That's the entire reason the term ``Open Source'' exists.
<aeth>
jgkamat: whose code? verisimilitude's? verisimilitude doesn't write particularly idiomatic Common Lisp. Although I can't really throw stones there, given that I use the define-function macro extensively instead of defun in quite a few places.
<jmercouris>
I find it to be quite well abstracted...
<jmercouris>
aeth: he is talking about my code lol
robdog has joined #lisp
<aeth>
oh
<jmercouris>
which makes some trades, because I try to make it emacsy in its configurability, but still Common Lisp
<aeth>
ah, probably not very idiomatic, either, if it uses Emacs-style APIs
<jgkamat>
I don't remember, it was a while ago and I didn't have enough time to keep looking, if I take another look I'll ping you the parts that I find confusing. The thing that really confused me was the RPC/xml/whaever bridge, I couldn't understand or change any of that from tinkering
<jmercouris>
and say it is a mess?
<jcowan>
verisimilitude: I am very interested in Gopher.
<verisimilitude>
I make an effort to use only the COMMON-LISP package if I can and I try to write it portably, according to the standard. I dislike when a program sees fit to pull in a single convenience function from some library; that's an inconvenience.
<aeth>
jmercouris: a simple defstruct definition (i.e. no fancy slot stuff) seems very weird to me
<jmercouris>
The XML RPC bridge is a *very* complex problem, so I don't think it is fair for you to judge a piece of code you do not understand
<verisimilitude>
Do you want to take a look at what I have so far, jcowan?
<aeth>
jmercouris: I personally only use defstruct when a slot's :type is very important and probably (at least in SBCL) optimized
<jmercouris>
aeth: has to do with using it as keys in a hash table, and how the equality operators traverse
<jcowan>
verisimilitude: Yes, please.
<aeth>
jmercouris: so in the function key, why do you push in a loop to an outer list instead of using something like loop's collect?
<verisimilitude>
Here it is; it's incomplete, though:
<verisimilitude>
Currently, it's just a Gopher menu parser; I don't think I'll be adding much more; one feature that will be neat is having :MENU to represent menus or a list, representing the contents, instead.
<Bike>
well, collect would do it in the reverse order
<aeth>
(you have to type 'y' before linking to a line on Github so it isn't nonsense as the file changes in later commits... I actually prefer Gitlab's UI here, where they actually have a "Permalink" button)
<jmercouris>
aeth: I would just have to move the push to the collect
<jmercouris>
and then reverse it...
<aeth>
jmercouris: ah, so you need the order reversed?
<verisimilitude>
As for the Gopher server, I'd want to have my own network library before I start on that; USOCKET is just BSD Sockets, which I dislike.
<jmercouris>
aeth: yes
LiamH has quit [Quit: Leaving.]
<jmercouris>
I don't think my code is fantastic, but I certainly wouldn't call it a "mess"
<Bike>
you could hypothetically do (loop for key-chord-string ... for keys = (cl-strings:split key-chord-string "-") for key-chord = ... collect (serialize-key-chord key-chord)
<Bike>
no push, but reversely ordered
<aeth>
verisimilitude: I also dislike usocket. It's unfortunate that we're going to have two parallel efforts here, although even without licensing issues we probably would have two parallel efforts anyway because of my very different requirements.
<aeth>
jmercouris: it absolutely is a mess because you use symbols instead of keywords in LOOP and that is the tabs-vs-spaces holy war in Common Lisp
<aeth>
:-p
<aeth>
jmercouris: It's weird to see you document a function in comments in the docstring position. I think normally they're documented above with ;;; in comments or in docstrings where you currently have your comments
<jmercouris>
oh I know, it was at a time where the aesthetics of the docstring de-denting to the 0th column really annoyed me after one line
<verisimilitude>
Oh, my network library will be CC0, aeth.
<verisimilitude>
Or, at least, I believe it will.
<verisimilitude>
It depends on how much work it is; if I'd licensed SHUT-IT-DOWN, which just abstracts over how to exit the implementation, under the AGPLv3, almost no one would use it, since it's so small, but with CC0 no one has a reasonable objection, really.
<aeth>
Ukari: I also get that weird indentation and have to manually override it. It's especially weird since it's just &rest clauses so I'm not sure why SLIME wants to indent the first element of a &rest
<jmercouris>
aeth: I've recently tried to make my comments conforming to the "standard" convention
rumbler31 has quit [Remote host closed the connection]
<aeth>
verisimilitude: The thing is, no one will use your AGPL library even if it is large and non-trivial. I am writing a very large and very non-trivial framework in Common Lisp and if it wasn't MIT licensed then even fewer people would pay attention to it than the few that currently do so.
<verisimilitude>
I use it, which is all I care about.
<verisimilitude>
I write it for myself, first, and everyone else, second.
<jmercouris>
verisimilitude: then why insist on GPL?
<jgkamat>
verisimilitude: if you send me a link when you're done, I'll use it :D
<aeth>
verisimilitude: that's the correct attitude to have
<aeth>
verisimilitude: if you don't write for yourself in the world of CL libraries it can be very demoralizing
<jmercouris>
if you are only writing for yourself, there is no logical justification for GPL
<verisimilitude>
I prefer the GPL, the AGPLv3, in particular.
<jmercouris>
jgkamat: are you still convinced Next is a mess :D?
<verisimilitude>
There's also the other reasons I've listed.
<jgkamat>
yes, I still don't understand the xml/rpc, do you have any docs for that?
<jmercouris>
Yes
robdog has joined #lisp
<jmercouris>
Next is however *not* a mess because of XML RPC
<jmercouris>
I will not lie, I am upset by the fact that you picked this particular point as a mess
<aeth>
jmercouris: if you're *only* writing for yourself, then there's no reason to even release the source, so (A)GPL is fine
<jmercouris>
because it is something that took almost a year of effort and a lot of deliberation
<jgkamat>
fwiw, though, I think almost all code is a mess, almost everything out there is pure garbage
<jmercouris>
and it was based on the reccomendation of a member of this community who I very much respect as one of the best Lisp developers and researchers of our time
<aeth>
jgkamat: I agree.
<jmercouris>
the fact that you do not understand it, does not mean it is a mess...
bilb_ono has joined #lisp
<jmercouris>
basically the XML RPC abstraction is so that a platform port can be independent of the Lisp Core
<jmercouris>
no foreign code ever touches the Lisp Core for safety
<aeth>
jgkamat: Most code just never reaches a level of polish that I would personally call "quality"
<jmercouris>
a separate program that controls the GUI effectively listens and communciates back and forth between the Lisp core
<verisimilitude>
I'll let you know when it's finished or at least given an initial release, jgkamat; you refer to CL-GOPHER, right?
<aeth>
jgkamat: calling most things a "mess" would probably be going too far, though. You should hang out in #clschool if you want to see what complete novice code looks like
<jgkamat>
yup, thanks verisimilitude :]
<jgkamat>
I actually use some gopher links so I might find it useful
<aeth>
jmercouris: I suspect that most code issues can be addressed in a matter of days/weeks.
<jmercouris>
it is in *no* way a mess, I know messes of code that I have written in the past, but remote.lisp, and the logic there, is not one of them
<aeth>
jmercouris: I personally would avoid using with-slots anywhere
<jmercouris>
aeth: well, the code is constantly evolving as my understanding of Lisp evolves
robdog has quit [Ping timeout: 252 seconds]
<jmercouris>
aeth: why avoid with-slots?
<aeth>
jmercouris: afaik accessors are *both* "higher level" and more efficient, essentially killing any reason to use slots except if the slot doesn't have a writer, which can be worked around by doing something like (... :accessor %foo :reader foo) and not exporting %foo.
Kundry_Wag has joined #lisp
<jmercouris>
I usually use with-slots to avoid having to write (slot object) over and over again
<aeth>
So I just do (with-accessors* (foo bar (baz quux)) foobar ...) and it gets turned into (with-accessors ((foo foo) (bar bar) (baz quux)) foobar ...)
<verisimilitude>
Note that CL-GOPHER would be distinct from a client written with it, which I'd pull in ACUTE-TERMINAL-CONTROL for, jgkamat. So, the code that understands Gopher would be distnict from the mass that combines it, an interface, and network code.
<jmercouris>
aeth: man, too bad about that license, if only it was GPL, then I would use it
<aeth>
jmercouris: no, see, the thing is, my MIT license is too restrictive and not CC0
<jmercouris>
I see it now, yes, you are right :P
<aeth>
jmercouris: I do need to spin off the general purpose utils from my game engine, though. They're mostly complete, unlike the engine, and they really are general purpose.
<jmercouris>
unfortunately yes, working on modifying usocket to support unix domain sockets
<jmercouris>
and that will be the new form of IPC in the next major release
<verisimilitude>
Also, here's something amusing: It was easier in my light testing to use SB-EXT:RUN-PROGRAM to call netcat than it was to use SB-BSD-SOCKETS or USOCKET, which I find pitiful.
<aeth>
verisimilitude: It's actually an issue. There are absolutely users who cannot use my MIT-licensed code because it is not public domain, such as the SBCL team if they wanted to use one of my utility macros internally to the implementation.
<jmercouris>
but if it were public domain, someone could modify it, put a lot of work into it and even make a profitable lisp business!
<jmercouris>
think of the consequences!
<verisimilitude>
Well, I agree that BSD or MIT is too restrictive for my tastes as well, but I wasn't aware you were serious.
<aeth>
verisimilitude: So I wasn't mocking you, I was just correcting jmercouris, who might have been.
<jmercouris>
I'm sorry that was a bit uncalled for, this is a political topic, and we know how it goes...
<verisimilitude>
It was uncalled for, I agree.
<jmercouris>
It was however not meant to be an attack against you, but rather the GPL, which I have grown so strongly to distate, I will not talk anymore about this though as it is both off-topic, and a conversation without resolution
<jmercouris>
jgkamat: I am already aware yes, hence the desire to move to unix domain sockets
<jgkamat>
(and ftr, that's what made me go from 'this is questionable' to 'this is a mess')
<jmercouris>
jgkamat: it is something wasamasa pointed out months ago as a potential vector, and since he made a very good case, I took him quite seriously
<jgkamat>
I think you could migitate it by just specifying localhost instead of binding to 0.0.0.0
<aeth>
Anyway, as far as I'm concerned, with-accessors* itself is too trivial to be copyrighted. The only non-trivial thing it does is check the types if it's a bindings list instead of a binding symbol, e.g. the (baz quux) in (foo bar (baz quux))
<jgkamat>
at least prevent remote people from connecting
<jmercouris>
jgkamat: it doesn't work how you think
<jmercouris>
and I really don't want to get into it
<jmercouris>
if you think that is enough to solve the issue, test it and submit a PR, they are welcome..
angavrilov has quit [Remote host closed the connection]
<jgkamat>
it won't solve the issue, but it will at least make people on your subnet not be able to do RCE on you
<jmercouris>
then it is pointless, usocket must support unix domain sockets, that is the only fix
<jmercouris>
and the only reasonable form of IPC, hence why we are working on that
bilb_ono has quit [Quit: bilb_ono]
<jmercouris>
I also refuse to use SBCL specific unix domain sockets, I want cross implementation compatibility
<jgkamat>
yes, unix sockets seems like the right solution to me at least
<jgkamat>
I don't understand what you mean by 'it is pointless' though
<jmercouris>
it is an incomplete solution, and therefore wasted effort
<jmercouris>
we only have so much time, so we only try to do complete solutions
<jmercouris>
half measures must eventually be rewritten and discarded
<jgkamat>
eh, I think that half protected is better than not protected at all
<jgkamat>
but it's your project, so feel free to do what you want :]
<jmercouris>
yes, but please, rephrain from calling it a mess, it isn't a very nice thing to say
<jmercouris>
its not even mean + constructive, it is just mean
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
sjl_ has quit [Ping timeout: 250 seconds]
anamorphic has joined #lisp
karlosz has quit [Quit: karlosz]
robdog has joined #lisp
gxt has joined #lisp
Josh_2 has quit [Ping timeout: 246 seconds]
ravenousmoose has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Zaab1t has quit [Quit: bye bye friends]
robdog has quit [Ping timeout: 252 seconds]
anamorphic has quit [Quit: anamorphic]
robdog has joined #lisp
lnostdal has quit [Quit: https://www.Quanto.ga/ -- Immutable state trading system in Clojure]
rumbler31 has joined #lisp
keep_learning_M has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
nowhere_man has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
<jackdaniel>
each time I think about projects I work on I see an endless ocean of mess. I think it is something inherent to lisp.
<jackdaniel>
not that it is a bad thing though ;-)
keep_learning_M has quit [Client Quit]
rumbler31 has quit [Ping timeout: 250 seconds]
<jackdaniel>
otoh usually it is a constructive mess (i.e when I spend a reasonable amount of time to grok things I see that doing it this paticular way makes a lot of sense), so the perceived mess-ness is just ignorance. but sometimes it is just a mess which needs to be fixed.
lavaflow_ has quit [Read error: Connection reset by peer]
pjb has quit [Read error: Connection reset by peer]
lavaflow_ has joined #lisp
<jmercouris>
jackdaniel: since you are here, I can ask you, this McClim TUI that you developed, would you suggest it for usage?
<jmercouris>
I would look up your article, but I can't remember what it is called
<jackdaniel>
no McCLIM TUI is published so far, so I can flat deny I work on such thing
pjb has joined #lisp
keep_learning_M has joined #lisp
<jmercouris>
You did work on a TUI of some sorts recently no?
<jackdaniel>
I've just shown a proof of concept that a reasonable CLIM backend could be written for CLIM
nalkri has quit [Ping timeout: 246 seconds]
<jackdaniel>
see above
<jmercouris>
So you would not describe it as a tool that one could just pick up and use
<jmercouris>
it is just a poc?
<jackdaniel>
thing described in a blog post (check out my blog!) didn't even touch CLIM
<jackdaniel>
that said I have a semi-working backend for McCLIM which renders to a console - it is not published nor workable yet though
<jackdaniel>
so no, I wouldn't recommend it :-)
lnostdal has joined #lisp
<jmercouris>
Ok
<jmercouris>
I knew it, I could have sworn it had something to do with McCLIM
<jmercouris>
my memory is usually pretty good, so when you said that you had not worked on a TUI backend for McCLIM I was very confused
<jmercouris>
what did Tisy2_ say that was so offensive?
<jmercouris>
and how much has Xach matured since this conversation?
robdog has quit [Ping timeout: 252 seconds]
<gilberth>
Heh.
<Xach>
jmercouris: I am more likely to think it and less likely to say it.
<gilberth>
Perhaps Tipsy_2 was the most offensive person I could find at that time [something like ten years ago] to demonstate incremental redisplay upon?
<jmercouris>
was he notoriously infuriating?
<jmercouris>
because looking at this isolated conversation, it seems quite an overreaction
<Xach>
Indeed.
<no-defun-allowed>
noss doesn't look too clean either, they don't know about ratios
<gilberth>
Sorry, then. Is he/she/it still arround?
<Xach>
gilberth: I don't think so. I think it was a one-time visit to check on and disparage the CL array indexing decision.
<jmercouris>
the decision to index from 0 is hardly unconventional though
<jmercouris>
many languages do it, why was this an issue?
<gilberth>
Xach: You frighten me. You still remember that?
<jmercouris>
and are you sure they did it just to get a rise out of you?
<gilberth>
And then my wife complains all the time about me, that I would remember everything. Seems like Xach is worse. :) But then I am olde.
<Xach>
gilberth: No, but the nick is not familiar, so if they visited more than once, it did not make much of an impression.
Nomenclatura has joined #lisp
<jmercouris>
so olde that you put an e at the end of old?
<jmercouris>
man, you must be at least 200 years old :D
<gilberth>
jmercouris: Blame Xache.
robdog has joined #lisp
<jmercouris>
has he aged you?
<Xach>
gilberth is so olde he still uses cmucl
<gilberth>
Oh, yes, I do at times.
<Fare>
so... you don't use CLOS too much, do you?
<jmercouris>
Fare: are you still using gerbil?
<Fare>
(my understanding is that CMUCL's CLOS has experienced breakage but nobody's there to fix it anymore)
<jmercouris>
I await your return to CL
<gilberth>
I love DEFSTRUCT and DO and DOTIMES and DOLIST. :)
<Fare>
jmercouris, yes and no... at $WORK it's OCaml.
meepdeew has joined #lisp
<jmercouris>
OCaml has been getting a lot of hype recently for some reason
<Fare>
but when I code some Lisp, these days it's Gerbil for new code, or Common Lisp for my legacy code.
<jmercouris>
Would you be interested in some sort of system definition facility?
<jmercouris>
I don't know, another one maybe?
<Fare>
jmercouris, for Gerbil?
<jmercouris>
No, I mean for CL
<jmercouris>
you could call it, another system definition facility or something, idk
<jmercouris>
just throwing out ideas
<jmercouris>
:P
<Fare>
for CL? I wrote two already, and a long TODO for a possible ASDF 4.
<Xach>
"A Lisper has gone / Uninterned from this mortal package / Yet not GC'd / While we retain pointers to his memory"
<jmercouris>
ASDF 4? that would be interesting
<Fare>
Won't be done by me (to the general relief).
<jmercouris>
Fare: whose relief? yours or everyone else's?
<Fare>
wait did I say I wrote two? Actually, it's three if you count bazelisp.
<jmercouris>
I don't think anyone had any complaints about the current ASDF implementation
robdog has quit [Ping timeout: 252 seconds]
<jmercouris>
I have never had a problem with it
<Fare>
jmercouris, you haven't been listening enough, then.
<jmercouris>
I guess you are probably contacted early
<jmercouris>
and directly
<Fare>
At least nikodemus, stassats and Xach are pissed at me. At least Xach for good reasons.
<jmercouris>
there is never a good reason for anger
<Fare>
(Not sure about Nikodemus, I discovered only 10 years later that he was pissed at me, he never told me why exactly.)
<jmercouris>
what would ASDF 4 do that the current implementation does not?
frodef has quit [Ping timeout: 255 seconds]
<jmercouris>
in brief, I know you said it is a long list
<jmercouris>
but from a user perspective, would it change my life in any meaningful way?
<Fare>
The biggest item that would justify a modicum of backward-incompatibility would be cross compilation.
<Fare>
While we're at it, we could add determinism.
andrei-n has quit [Remote host closed the connection]
<jmercouris>
determinism? ASDF is non-deterministic?
<jmercouris>
I assume that is by accident, and not design, yes?
<Fare>
Totally non-deterministic: everything is done via side-effects to the current image state.
<jmercouris>
without knowing a lot, that does seem to me a dangerous way to operate
<Fare>
more as a necessary consequence of the architecture: you can never protect against someone or something side-effecting the environment.
<jmercouris>
so the state of the image could be anything
<jmercouris>
and thus you cannot know what will happen when you load a system
<jmercouris>
that makes sense
<Fare>
if anyone dynamically calls ASDF while some of the reader variables are bound to non-standard values, the result can be "interesting".
<jmercouris>
I don't see how else you could do it though
<Fare>
I have a branch to address this issue, but it hasn't been merged in 5 years or so.
<Fare>
jmercouris, forking / spawning at every build command is how other systems do it.
<jmercouris>
you just shattered my whole image of ASDF
<jmercouris>
I was quite impressed with the software until you mentioned this :D
<Fare>
of course, you'd have to fork / spawn from a "clean" state.
<jmercouris>
nah, but seriously, I think it's a great piece that you've built
<jmercouris>
and for all of those that have complaints, valid they may be, but it is easily top 3 most meaningful contributions to the Lisp Ecosystem, so thank you for that
<Fare>
well, most people most of the time have the discipline and decency not to do anything too bad with the lisp image while they build. But that's not a guarantee.
<Fare>
I haven't built it, just grown it.
<jmercouris>
anyone who does anything else, gets what they deserve
<jmercouris>
whatever, you are frequently credited with UIOP/ASDF, and I think those are of great value, so thank you
random-nick has quit [Ping timeout: 252 seconds]
<Fare>
yes, but they also pollute the system for others.
<aeth>
as far as being indexed at 0 instead of 1... that is the worst reason to not use CL... just write a macro or inline function to do the (1- index) translation if it's too hard to translate the elaborate 1-based algorithm (e.g. a matrix one).
<Fare>
I am grateful for your appreciation.
<Fare>
aeth, I'm not sure what you mean. Like, nth and aref starting their indexes at 0 ?
<aeth>
Yes. I actually use a matref macro (has to be a macro because of the inline expansion limit) for matrix code because all of that (well, the raw math and algorithms as opposed to concrete implementations) is 1-based and I don't want to make a logic error translating it.
<aeth>
As far as problems with ASDF, the (nitpick) problem I have with it is that it's not at all easy to add support for other languages, even though it seems to be theoretically possible.
<aeth>
I guess this exists because not too many people have tried.
robdog has joined #lisp
<Fare>
aeth, ASDF was not directly designed for it, but it's possible.
<Fare>
I've done my share of adding support for compiling and linking C code with ASDF.
varjag has quit [Ping timeout: 246 seconds]
robdog has quit [Ping timeout: 252 seconds]
meepdeew has quit [Remote host closed the connection]
<Fare>
though if I were still maintainer, I'd consider moving this support from a cffi gadget to asdf itself. Maybe. Or then again maybe not.
<aeth>
Well, my main complaint is that it seems to require adding a lot of different things in many different places, which requires a decent understanding of ASDF internals, at least when I was looking into it. There isn't just one or two places to add methods.
<Fare>
the ASDF internals are still underdocumented. But at least there are documents that explain them nowadays. That used not to be the case.
<Fare>
My understanding is that no one really understood ASDF 1, not even danb.
<Fare>
a lot of bad ideas inherited from mk-defsystem were in it, too.
keep_learning_M has quit [Quit: This computer has gone to sleep]
<Fare>
I would recommend my 25-page ASDF 3 essay if you want to grok ASDF internals. At least the parts that discuss the object model.
<Fare>
it's weird, but it was a very interesting invention by danb (as inspired by Kent Pitman).
igemnace has quit [Quit: WeeChat 2.4]
<Fare>
and got a lot of things remarkably right (though annoyingly, a few things wrong, too)
<jasom>
aeth: I've settled for just adding a dummy lisp file that invokes a native build system (such as make) when loaded.
<jasom>
and then adding plain-file dependencies to the dummy lisp file as needed.
<Fare>
Retrospectively, one thing that surprised me most was that in the old MIT Lisper vs Unix hacker debate, the Lisper claimed to be seeking the "Right Thing" when the hacker was looking for "good enough", but ASDF 1 and most Lisp libraries I've seen were much more "good enough" than "the Right Thing". Maybe it's a generational thing, too. I became a Lisper in the 2000s, when that debate was from the 1980s.
<jasom>
Fare: though it should be said that nearly all build systems are more "good enough" than the "Right Thing"