<jasom>
it3ration: series is a lazy-ish thing, but it doesn't seem to be very popular
<jasom>
It seems to be more common to explicitly iterate over a generator function rather than have a lazy list
<jasom>
(in common lisp that is)
Lycurgus has quit [Quit: Exeunt]
it3ration has quit [Ping timeout: 240 seconds]
<aeth>
What's the best way to assert two things? If you assert them separately, you risk the user correcting the 2nd assert by providing something that fails the 1st assert. If you assert them together, then the user does not know which of the two failed in particular.
ealfonso has quit [Ping timeout: 250 seconds]
<aeth>
The only thing I can think of right now is doing the assertion test twice, once together in the assert and then again in the error message.
papachan has quit [Quit: WeeChat 2.2]
elfmacs has joined #lisp
quazimodo has joined #lisp
mindCrime has quit [Ping timeout: 240 seconds]
zxcvz has quit [Ping timeout: 272 seconds]
shlemas has quit [Quit: shlemas]
shlemas has joined #lisp
SenasOzys has quit [Ping timeout: 250 seconds]
JuanDaugherty has joined #lisp
PuercoPop has joined #lisp
charh has quit [Ping timeout: 240 seconds]
zxcvz has joined #lisp
zxcvz has quit [Client Quit]
zxcvz has joined #lisp
shlemas has quit [Quit: shlemas]
JuanDaugherty has quit [Quit: Exeunt]
SenasOzys has joined #lisp
Lycurgus has joined #lisp
v0|d has quit [Remote host closed the connection]
dddddd has quit [Remote host closed the connection]
papachan has joined #lisp
serichsen has quit [Ping timeout: 252 seconds]
mange has joined #lisp
SenasOzys has quit [Ping timeout: 240 seconds]
papachan has quit [Ping timeout: 252 seconds]
jack_rabbit has quit [Ping timeout: 250 seconds]
jack_rabbit has joined #lisp
anewuser has joined #lisp
buffergn0me has joined #lisp
igemnace has joined #lisp
zotan has quit [Ping timeout: 276 seconds]
Lycurgus has quit [Quit: Exeunt]
mindCrime has joined #lisp
quazimodo has quit [Ping timeout: 240 seconds]
it3ration has joined #lisp
quazimodo has joined #lisp
renzhi has joined #lisp
it3ration has quit [Ping timeout: 246 seconds]
meepdeew has joined #lisp
mindCrime has quit [Ping timeout: 246 seconds]
papachan has joined #lisp
quazimodo has quit [Ping timeout: 240 seconds]
quazimodo has joined #lisp
danielxvu has joined #lisp
lemonpepper24 has joined #lisp
Roy_Fokker has quit [Read error: Connection reset by peer]
Bike has quit [Quit: Lost terminal]
jinkies has joined #lisp
pierpa has quit [Quit: Page closed]
caltelt has joined #lisp
NB0X-Matt-CA has quit [Ping timeout: 245 seconds]
<earl-ducaine>
A style question for Lispizens! I've always considered &aux barbaric. But I realize such conventions are usage driven more than from a perspective of practicality.
<earl-ducaine>
A quick survey of local ql seem to indicate that it's a rare usage, but not absent. Do people have strong personal preferences? Have they seen code where its usage is styalistically prefered in certain contexts?
elfmacs has quit [Ping timeout: 252 seconds]
NB0X-Matt-CA has joined #lisp
panji has joined #lisp
asarch has joined #lisp
it3ration has joined #lisp
<pierpal>
nobody uses &aux. it's a fossil from prehistoric lisps.
<drmeister>
Say you are in the process of typing in form: (foo (bar "this is a" 1 2 3 <point> . What libraries would help me find "bar"?
<pierpal>
to be more precise, it is there to allow some compatibility with interlisp
<drmeister>
I've used &aux in certain contexts.
<pierpal>
I knew someone would have objected :)
<drmeister>
Object? It's part of the standard - it's handy when you want to define a compact lambda.
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
<beach>
Good morning everyone!
<drmeister>
Hi beach
<drmeister>
beach: Say you are in the process of typing in form: (foo (bar "this is a" 1 2 3 <point> . Could eclector help me find "bar"?
<beach>
Sure.
<beach>
You need to parse the input, so it can be a "parse result" or a CST.
<beach>
I am not sure whether scymtym has finished the possibility of parsing incomplete input, but it is planned.
nanoz has joined #lisp
<beach>
Then you need to know the position of <point> in the parsed expression.
<beach>
Then you just ask the implementation for the definitio of BAR.
<beach>
definition
<no-defun-allowed>
morning beach
<drmeister>
I can get the position of point in the parsed expression by comparing the source location of each cst element to the position of the <point>?
<beach>
Definitely.
<beach>
You would probably do a tree search. Start with the root, figure out in which child it is, search that child recursively, until you are either in a leaf, or between two children.
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
quazimodo has quit [Ping timeout: 240 seconds]
quazimodo has joined #lisp
jinkies has quit [Ping timeout: 250 seconds]
gector has quit [Remote host closed the connection]
gector has joined #lisp
panji has quit [Quit: Leaving]
orivej has joined #lisp
<no-defun-allowed>
okay, very important style question here: should i spell quanti[zs]e and normali[zs]e with a Z or S?
<no-defun-allowed>
i'd assume CL uses american spelling
<beach>
Typically, yes. But I think as long as you are consistent, you should be fine.
quazimodo has quit [Ping timeout: 250 seconds]
quazimodo has joined #lisp
<no-defun-allowed>
i already went with "colours" too so i guess i'm stuck with british english
<no-defun-allowed>
at least i don't have to measure my images in inches
<edgar-rft>
amerian would be colorz :-)
<no-defun-allowed>
i'm working on a simple video effect processor cause kdenlive's green screen is horrid
<edgar-rft>
The CL ANSI spec is an american thing. The arpanet was too slow at that time so communicating with europe was abandoned (if I know that right).
<jackdaniel>
"arpanet was slow"? how long did email travel from us to europe? maybe they should use the postmail
<jackdaniel>
from what I've read (I don't remember the sources) they simply didn't include europe because were not interested in suchc cooperation
<jackdaniel>
otoh one could argue, that Kent Pitman was one of these guys. who'd say: "because *we* didn't want to cooperate with them" ;-)
<jackdaniel>
?
asarch_ has joined #lisp
<oni-on-ion>
you had a link
anewuser has quit [Read error: Connection reset by peer]
<edgar-rft>
...and of course there was no arpanet outside of the US, but I don't know what else they used for email at taht time
asarch has quit [Read error: Connection reset by peer]
<oni-on-ion>
we have lisp in prolog and prolog in lisp, in several ways. what about symbolics network, was it called ghost ?
<PuercoPop>
Is there a way to 'right align' with format when specifying a width? ej. "depth ~2A" where the A is going to be a number. I want the extra space to be at the before inserting the number if it is only a 1 digit one.
<phoe>
beach: it's not really a Lisp question, but, we have a tree (or even, a trie) of words like the ones that you have constructed. That way, we can look up words that are correct.
<phoe>
Now, based on that, we need an algorithm that will look up suggestion for words that were not found. For example, we have "across" in the example dictionary that you created, and we'd like it to turn up as a suggestion if we type "acros".
<phoe>
Or even, "akross".
<phoe>
I also assume that you want to be automatically able to parse the english-* files in your repository and create entries based on each line inside them.
<shrdlu68>
Levenshtein distance could help in the first case.
<phoe>
Yep, reading about it right now
it3ration has joined #lisp
<shka_>
phoe: ues some metric and data structure for faster lookup
<shka_>
m-tree, egnat, whatever
<shka_>
cl-ds has egnat implementation
<shka_>
if you are doing java, go for elastic search
<shka_>
sort of overkill but it works well
<shka_>
if you need to find word with similar meaning, things are slightly more complicated
<shka_>
ok, time to get stuff done
quazimodo has quit [Ping timeout: 252 seconds]
it3ration has quit [Ping timeout: 252 seconds]
quazimodo has joined #lisp
dtornabene has joined #lisp
panji has joined #lisp
buffergn0me has quit [Ping timeout: 250 seconds]
<beach>
phoe: What shrdlu68 said. There are algorithms for that kind of stuff.
xificurC has joined #lisp
<beach>
shka_: Faster lookup won't be necessary. Most of the time, the exact match will be found, and when it is not, it is more important to get good advice that to get good performance.
<xificurC>
given this cl-i.asd file: http://ix.io/1lDG I can (asdf:load-system :cl-i) and get T but (asdf:test-sytem :cl-i) just returns T without actually running the tests. Is there some glaring error in the definitions of the systems?
<shka_>
beach: why not both? :-)
<beach>
shka_: Sure, with unlimited staff resources, that's a good plan.
<beach>
shka_: But we don't have that, so wee need to think about simplicity and maintainability.
<xificurC>
for the record I cannot (asdf:load-system :cl-i-tests) this way. I'm not sure what is the idiomatic way to organize a library and its tests
<shka_>
well, ok
<jackdaniel>
xificurC: shouldin't it be in :cl-itests definition
<jackdaniel>
:in-order-to (test-op (o c) (uiop:symbol-call :1am :run)) ; ?
mange has quit [Remote host closed the connection]
<beach>
xificurC: ASDF finds the system based on the name of the file. So if the name of the file is not cl-i-tests.asd then it won't find your system.
<xificurC>
beach: cl-i.asd
<jackdaniel>
beach: in fact it will, because in order to find cl-i (which is tested) it must load whole asd
<xificurC>
as pasted there's 2 systems defined in 1 file
<jackdaniel>
so the side effect will be registering -test system
<beach>
jackdaniel: That works only if cl-i has been asked for first.
<jackdaniel>
yes, and it is called like (asdf:test-system :cl-i)
<jackdaniel>
so the direct reference is to :cl-i which must be found
<beach>
But nothing was said about cl-i having been requested first.
<xificurC>
beach: it was, read the first inquiry
<jackdaniel>
according to what I've read above (asdf:test-system :cl-i) is called
<beach>
Oh, sorry, missed it.
<jackdaniel>
not that depending on side-effects is wise
<jackdaniel>
xificurC: if you define it in the same file, way recommended by asdf authors is to name it cl-i/tests
svillemot has quit [Quit: ZNC 1.6.5+deb1+deb9u1 - http://znc.in]
<xificurC>
yes there's a slash, if that is part of the best practices advice I can rename it
svillemot has quit [Client Quit]
<jackdaniel>
magic name conventions affecting library behavior are something what makes my day ;)
<jackdaniel>
(every time)
<xificurC>
you think renaming it will make it to work? haha
<jackdaniel>
no, I think that problem is soemthing else
<jackdaniel>
I'm just expressing my dissatisfaction with asdf
svillemot has joined #lisp
<scymtym>
i guess the SYSTEM/SUB-NAME naming requirement for defining multiple systems in the same file was chosen because SYSTEM/SUB-NAME.asd would not be a valid filename
orivej has joined #lisp
<phoe>
beach: just a minor finding, you defclass NODE but don't use it as a superclass of anything later on.
<jackdaniel>
I'm aware of that, still it is just one step from making comments affecting inner workings of your library
<scymtym>
that's an exaggeration but i'm not going to argue
<xificurC>
I have no idea why this isn't working. Before I had 2 asd files but I was the best practices page do it in 1 and thought it might be cleaner
<xificurC>
so now I'm in the stage where someone might say it's cleaner, but it's not working :)
<beach>
phoe: That's entirely possible.
<beach>
Thanks.
zfree has joined #lisp
<phoe>
beach: I assume that I should, for now, focus on a way of parsing the english-* files, correct?
<xificurC>
the fact that it returns T is really strange though
<phoe>
And once that's done, I need to figure out how much memory the loaded dictionary uses.
<beach>
phoe: Probably so, yes.
<scymtym>
xificurC: your example seems to work here. it returns t as you observe, but i see "Success: 0 tests, 0 checks." being written to standard output
<scymtym>
(between asdf warnings, of course)
<xificurC>
what warnings
<beach>
phoe: If you store a single character per node, it may be a bit more expensive than necessary, but that might not be a problem.
<scymtym>
xificurC: about naming the secondary system "cl-i/test"
<phoe>
beach: your code seems to do exactly that, storing one character per node.
<phoe>
But I'll worry about optimization later.
<beach>
Yes, and I don't think it is a problem.
<xificurC>
I'm pushing a path to asdf:*central-registry* to get my asd found, can there be a difference in what asdf does with a system found this way? Before asking, yes, I have to.
<beach>
phoe: The total contents of all the files is a bit more than 5 MB.
Bronsa has joined #lisp
<beach>
phoe: But many prefixes will be shared, and you don't have to store every basic form with every derived form.
<beach>
phoe: So I am willing to bet that you will be fine with the simple structure.
<scymtym>
xificurC: i don't know/use ASDF:*CENTRAL-REGISTRY*, sorry
<phoe>
beach: 5 MB? I don't understand just yet.
<beach>
Oh, sorry, much more.
<beach>
I misread the output.
<phoe>
The english-* files, when summed up, are hundreds of megabytes.
<jdz>
xificurC: asdf:*central-registry* is deprecated, btw.
<beach>
Yes, yes.
<beach>
Sorry.
<beach>
Not my day, apparently.
<phoe>
Three hundred megabytes. I assume the tree will compress it a little bit.
<phoe>
Again, I have enough RAM - I'll think about optimizing this later.
<beach>
phoe: So yes, try the simple thing and see how much space it takes.
<phoe>
Okiedokie.
<beach>
Exactly.
<phoe>
Also, one more thing - I don't even have to store the final forms of the words in the leaf nodes. The tree structure is enough.
<shka_>
obviously
<phoe>
Yep - beach's code is currently doing that.
<phoe>
So there's plenty of space for optimization.
<phoe>
I'll parse the dict files first and load them up second.
azimut_ has joined #lisp
azimut has quit [Ping timeout: 252 seconds]
<phoe>
beach: gan
<phoe>
woops, sorry
<phoe>
beach: gah
<phoe>
it seems that these english-* files contain a hell lot of repetition
<phoe>
they seem a little bit like they're one and the same file, but differently processed
<phoe>
like, english-1 contains words in some kind of dictionary notation where english-16 contains them in quasi-Lisp notation
<phoe>
Hm. I'm looking at ref1pl. I think I know how to translate ref3pl based on that. (I hope.)
<phoe>
Okay. Next.
<phoe>
"to" :base "to" :type :verb TO
<no-defun-allowed>
A SB-KERNEL::HEAP-EXHAUSTED-ERROR condition without bindings for heap statistics. (If you did not expect to see this message, please report it.
<no-defun-allowed>
i didn't expec that, no
<phoe>
...if I understand it correctly, it means that "TO" is special, as in, it's a part of some kind of infinitive verb. "to write"
<phoe>
no-defun-allowed: sounds like #sbcl
<no-defun-allowed>
i can imagine how my stupidity caused that so it's probably not very interesting
housel has quit [Read error: Connection reset by peer]
housel has joined #lisp
<no-defun-allowed>
i blew the stack at least five times being stupid with bad parallelism
<phoe>
stack? or heap?
<no-defun-allowed>
my bad, heap
<phoe>
stack is per-thread, heap is per-process
<phoe>
yep
<no-defun-allowed>
used to blowing stacks instead of heaps
<phoe>
why not both?
<no-defun-allowed>
cause my genius solution to coordinating writes to one stream from twelve workers is through a counter and hashtable
<no-defun-allowed>
if the writer signals a condition, handler-case hopefully sets a kill flag and the threads return early
<no-defun-allowed>
since the writer is slow, workers wait if the difference between writer frame and workers frame is greater than 500
<phoe>
Yep, I see
m00natic has joined #lisp
<no-defun-allowed>
that 500 frames is apparently 2.2gb so i might need to lower that further
orivej has joined #lisp
<no-defun-allowed>
(the moral is: don't bother fuzz testing, just give me a keyboard and repl and i'll break shit somehow)
<phoe>
beach: there is only one word in the original english-1 dictionary that is PASSIVE and it seems that your VERB class does not have a slot for holding that information. Should I add a slot for that single word or should I convey this information in some other way?
<no-defun-allowed>
i really want to try getting opencl support in cl-vep cause it'd be much faster i think but i don't have any opencl gpus
<phoe>
beach: ....isn't "born" actually a perfect participle or something? Or is "passive verb" a thing in English?
Lycurgus has joined #lisp
LdBeth has quit [Remote host closed the connection]
no-defun-allowed has quit [Read error: Connection reset by peer]
<phoe>
I'll just ignore that one.
igemnace has quit [Quit: WeeChat 2.2]
<phoe>
I loaded the whole dictionary
<phoe>
And the RAM usage isn't all that scary
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
nsrahmad has joined #lisp
SenasOzys has joined #lisp
dmiles has quit [Ping timeout: 244 seconds]
no-defun-allowed has joined #lisp
elfmacs has joined #lisp
logicmoo has joined #lisp
nowhere_man has joined #lisp
<beach>
phoe: I have no preference what solution to take.
<beach>
phoe: And no, "born" in that sense is not the perfect participle of any verb in active form.
quazimod1 has quit [Ping timeout: 245 seconds]
makomo has joined #lisp
quazimodo has joined #lisp
<phoe>
beach: I see.
gector has quit [Read error: Connection reset by peer]
gector has joined #lisp
<phoe>
oh boy, 347491 words loaded
<phoe>
beach: can I work on your repository, or should I fork it and work on my copy?
trocado has joined #lisp
Bronsa has quit [Ping timeout: 260 seconds]
<trocado>
hi all! commonqt/qtools question: is it possible to have qt *not* blocking the repl?
<trocado>
Shinmera: I saw your redefinition video, but couldn't reproduce...
<trocado>
it would be nice to be able to create a window with a simple gui to inspect some things, but keep working on the repl
<Shinmera>
Qt needs to be run from the same thread always. As long as that's ensured it's fine.
<trocado>
I tried making a new thread for it but then it complains that it's not running on the main thread
<phoe>
trocado: you have to run *ALL* of Qt on one thread
<phoe>
you can't make and run the QApplication in thread A and then execute stuff in thread B
<shka_>
trocado: it registers main thread during initialization
<Shinmera>
The keyword in what I wrote is always
<trocado>
i see
<phoe>
trocado: what do you need from the REPL though?
<phoe>
I do redefinition by C-c C-c inside emacs when I want it
<phoe>
this gets sent to a swank compilation thread and executed there
<shka_>
trocado: it is the best to build event loop for qt to run and simply post everything there
<Shinmera>
You can also eval things by C-c C-c if you need
<trocado>
yes, i'm thinking this over and maybe it's ok if I have to close the window to get back to the repl
SenasOzys has quit [Remote host closed the connection]
SenasOzys has joined #lisp
<trocado>
another thing: is it possible to create a window in the foreground (with focus)? it always goes immediately under emacs...
nsrahmad has quit [Remote host closed the connection]
<phoe>
beach: I'm making a fork and a proper ASD system. How is your spell code licensed?
it3ration has joined #lisp
edgar-rft has quit [Remote host closed the connection]
<TMA>
phoe: born is indeed a perfect participle of bear, as is borne; the two are used for different senses of bear -- an oddity every bear can bear (and has borne since time immemorial) but no bear has born it
<phoe>
TMA: thanks
it3ration has quit [Ping timeout: 240 seconds]
makomo has quit [Ping timeout: 246 seconds]
<beach>
phoe: BSD as usual I think.
lavaflow has quit [Ping timeout: 240 seconds]
rumbler31 has joined #lisp
Bronsa has joined #lisp
rumbler31 has quit [Remote host closed the connection]
<phoe>
beach: it's working decently.
<beach>
Wow, that was fast.
<phoe>
The only thing I'll want to do is dumping the final tree structure into the FASL, so it is not regenerated on each load.
<phoe>
This means I'll need to write a bunch of MAKE-LOAD-FORM-SAVING-SLOTS I guess...
makomo has joined #lisp
<lieven>
another case of different perfect participles is hanged vs hung
<phoe>
└─▪ ls -alh english.fasl
<phoe>
-rw-r--r-- 1 phoe phoe 37M sie 31 14:18 english.fasl
<phoe>
beach: that's 37M SBCL FASL, before any serious optimizations.
<phoe>
But (ql:quickload :spell) takes only 1 second instead of 18.
<phoe>
If I drop all :BASE strings, we trim this down to 23M.
<beach>
phoe: The :BASE should point to another occurrence, no?
<phoe>
beach: actually it does not, it contains a string.
<beach>
I know it does in the source.
<phoe>
Inside english-1, it points to a string.
<phoe>
There are often multiple words associated with a string.
<beach>
But in the final data structure, I think it should point to another occurrence.
<beach>
Oh, I see.
<phoe>
Like, if you get pointed to "horse", it's not obvious if it points to the verb "horse" or to the noun "horse".
<phoe>
The source does not make this clear in any way.
<beach>
Wow, that's no good.
<beach>
Yes, well, the base of a verb is (almost) always a verb in infinitive form.
<beach>
A noun is the singular form.
<phoe>
We need a better source for that kind of occurrences though.
<phoe>
The value of that slot is a list of children.
<beach>
Yes, I see.
<phoe>
You have interior-mixins and leaf-mixins.
<phoe>
Which is okay, I think.
<beach>
I think there might be more compact ways of representing that stuff.
<beach>
I'll look into it.
<phoe>
beach: yep. It seems we're going into the optimization phase now.
<beach>
It might not be worth the effort though.
<beach>
I am certainly willing to use it as it is.
<shka_>
hmm
<phoe>
beach: It will be worth the effort, definitely
<phoe>
Just not now, I guess
<phoe>
I'll eventually want to ship it with some application and that's when I'll be looking into making this stuff more compact.
<beach>
OK.
SenasOzys has quit [Ping timeout: 245 seconds]
<shka_>
so interior-node is node of trie?
<phoe>
shka_: node is a node of a trie
<phoe>
there are two kinds of mixins in there
<phoe>
interior nodes, which have children
<phoe>
and leaf nodes, which contain words
<shka_>
phoe: yeah, but i want to figure out how trie is represented
<phoe>
there are of course interior leaf nodes
<phoe>
yep, interior nodes are the building blocks of the trie
<shka_>
uh, why two types of nodes?
<shka_>
just to preserve slot?
<phoe>
I guess
<phoe>
not all of them have to be interior
<phoe>
and not all of them have to be leaves
<phoe>
so I guess that a pair of mixins is a sane case in here
<ebrasca>
I can't load reblocks in debian. ( I can load it in my other distros )
<phoe>
and a single preserved slot in 380K instances can sum up decently, I think
trocado has quit [Ping timeout: 240 seconds]
gravicappa has quit [Ping timeout: 272 seconds]
<beach>
phoe: One important question to answer is this: Is it OK to return different (in the sense of EQ) instances for two different queries for the same word?
<shka_>
well, i would make all nodes contain the same content: bitmask representing what children are present, another mask to represent what words are present, and vector of children
<beach>
phoe: If so, then one could represent the leaf information in a much more compact way.
<phoe>
beach: yes, I see.
<phoe>
beach: as long as we document it, we probably don't have to.
<beach>
shka_: What do you mean by "what words are present"?
<shka_>
not sure if bitmasks are better then ordered sequences here, though
<phoe>
bitmask of what?
<beach>
Exactly my question.
<shka_>
beach: not every prefix must be a word i think
<phoe>
yes, that's why not every node is a leaf node
orivej has quit [Ping timeout: 245 seconds]
edgar-rft has joined #lisp
<beach>
One important thing to measure is the total amount of space taken up by the leaves compared to the grand total size. It is entirely possible that the tree structure itself is a small part of the total size.
<phoe>
......I completely forgot that #'ACONS was a thing
<phoe>
The tree is pretty sparse I think
<beach>
If that is the case, then the only way to decrease the space is to encode the words differently, possibly abandoning the EQ property.
<beach>
I invoke Ousterhout's article again. Measure before working to hard on the wrong part.
<beach>
too hard, even.
<beach>
phoe: That is not the point.
<beach>
phoe: The point is that if interior nodes are a small part of the total amount of space, then optimizations like the one shka_ suggests won't buy much.
<phoe>
beach: I see.
<shka_>
yes
<shka_>
luckly, it can be measured!
<beach>
So measure, measure, measure.
<beach>
And by all means, read the article.
<phoe>
Do you have a link to it?
<shka_>
anyway, once again: measure before optimize
<beach>
phoe: You can count the number of instances and estimate the space per instance.
<francogrex>
in this post https://pastebin.com/0UL9APLq anyone have a clue why i am getting the error Attempt to call an undefined alien function? I am using sbcl 1.4.2 for x86 32 bit. could that be the problem, the 32 bit v of sbcl?
<phoe>
beach: I know what we can do with regard to the bases.
<beach>
What's that?
<phoe>
We don't have to store the strings for bases - instead, we can point to the proper leaf node.
<phoe>
For example, if we have a word that has a base "horse", we can point to the leaf node for the final letter #\e.
<phoe>
And, from it, the dictionary could get the list of entries for that node.
<phoe>
I guess we can shave another 12M that way.
<phoe>
Except no, we're in trouble now.
<phoe>
We can't really travel upwards from the leaves, so if we point to the last letter, then we still have no idea what the base is.
<phoe>
We might know there's a verb and a noun there, but we have no means of figuring out the string for the base, "horse".
<phoe>
This means that we'll need a parent reference on each single node.
<shka_>
temporary path constructed when searching the tree won't do?
<phoe>
Not really
<shka_>
ah, right, eq thing
<phoe>
You have found your way to a word, for example, called "enhorsement"
<phoe>
That has a base called "horse"
<beach>
phoe: I have an idea...
<phoe>
It's in a completely different part of the tree.
<phoe>
beach: what is it?
<beach>
You don't have to return the word that was used in the query.
<jackdaniel>
I wonder if it is a bit too much to paste an "in motion" low-level application analysis on general #lisp channel
<beach>
The client knows it.
<phoe>
beach: Yes, I know.
trittweiler has quit [Ping timeout: 260 seconds]
<phoe>
I don't mean that word though.
<beach>
phoe: If you remove the spelling from the word, lots of "words" will be identical.
<beach>
And you can share them.
<beach>
jackdaniel: Give us a few more minutes.
<phoe>
If the client searches for "enhorsement", the base for that word will be "horse".
<jackdaniel>
I'm not in position to give or take something, just a suggestion that this may be too cluttering for people who bother reading backlog
<beach>
OK, I'll be quiet.
<phoe>
Oh right. Sorry for that.
<splittist>
I was enjoying that. But I don't read logs, so the live experience means more to me than extracting information later. Back to your regular discussions about why scheme, clojure and emacs questions are off-topic.
SenasOzys has quit [Ping timeout: 272 seconds]
steiner has quit [Remote host closed the connection]
<shka_>
beach: neat idea though
milanj has joined #lisp
<beach>
shka_: Watch us! We will squeeze it down to almost nothing. :)
steiner has joined #lisp
<phoe>
hey, we're already diving into MOP territory
<phoe>
implementing storage for word metadata as bit vectors
it3ration has joined #lisp
<shka_>
phoe: i was going to suggest that
<shka_>
though i have no idea why MOP
SenasOzys has joined #lisp
<shka_>
i don't use bit vectors
<shka_>
like… ever
<phoe>
shka_: so you can have slots that read one of :foo :bar :baz ...
<phoe>
while you don't store a full pointer in a slot
<phoe>
merely a few bits in a bit vector
<shka_>
ok
<shka_>
well, i would simply stick to function
<phoe>
this way, if you have eight possibilities, you go from 64 bits (a full pointer) to 3 bits in a bit vector
lavaflow has joined #lisp
it3ration has quit [Ping timeout: 252 seconds]
quazimodo has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
igemnace has joined #lisp
quazimodo has joined #lisp
lavaflow has quit [Ping timeout: 245 seconds]
mindCrime has quit [Ping timeout: 246 seconds]
<AeroNotix>
jackdaniel: booo
<jackdaniel>
AeroNotix: could you elaborate please?
zxcvz has quit [Quit: zxcvz]
shrdlu68 has quit [Ping timeout: 252 seconds]
cage_ has joined #lisp
orivej has quit [Ping timeout: 252 seconds]
elfmacs has quit [Ping timeout: 240 seconds]
<makomo>
just my 2 cents: i enjoy reading discussions like those as well. i know why the "off-topic rule" exists, but sometimes an exception should be made imo, especially if the channel is quiet anyway
<dlowe>
as long as it's on a lisp project, I'm fine with it.
<makomo>
agreed
eschatologist has quit [Ping timeout: 240 seconds]
varjag has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
<jackdaniel>
my point was not that it was offtopic but rather that it is to narrowed and makes reading other messages harder. imagine everyone talking about nitty-gritty details of projects they work on. but if this kind of moderation is not welcome, I'll just shut up and work on my own things
eschulte has joined #lisp
eschatologist has joined #lisp
jack_rabbit has quit [Ping timeout: 252 seconds]
trittweiler has joined #lisp
dale_ has joined #lisp
<phoe>
jackdaniel: it's no easy task to figure that sort of thing out
dale_ is now known as dale
<phoe>
if it's already off-topic and/or if it should stay here or move elsewhere
<AeroNotix>
jackdaniel: my thinking is that if, during the discussion of minutiae of some topic that someone enters and asks something more related to the real topic of the channel, the in-flight discussion should drop/pause and focus on the more topic related discussion
<AeroNotix>
I missed the initial part of the discussion. It seemed like an interesting discussion on how to optimize storage/lookup of some kind of trie/tree datastructure related to phoe's queries last night on dictionaries.
<AeroNotix>
Anyway, I have a question that I think I already know the answer to: is defvar the ONLY way to allow dynamic binding?
joast has quit [Quit: Leaving.]
<phoe>
AeroNotix: no
<phoe>
DECLARE SPECIAL
<phoe>
......and also defparameter, obviously
<makomo>
AeroNotix: both defvar and defparameter unconditionally proclaim the given symbol (the variable's name) as special and then maybe do some binding/assigning of their own
<phoe>
also you can have an arbitrary number of functions between FOO and BAR
<phoe>
as long as they do not poke the special variable named X, the value will be transmitted all the way to the BAR call
<phoe>
untouched, and such
<AeroNotix>
jesus, ok. That's interesting behaviour (local special variables)
<phoe>
yep
<phoe>
note that you can get rid of the declarations and (defvar x)
<phoe>
which gives you (defun foo () (let ((x 42)) (bar))) and (defun bar () x)
eddof13 has joined #lisp
<oni-on-ion>
i often feel that lisp can be lower level than C
<beach>
AeroNotix: It is not a "local special variable". It is just a declaration that tells the compiler to treat references to that variable in that scope as references to THE special variable.
<AeroNotix>
beach: thanks for the clarification
<beach>
Sure.
<makomo>
beach: regarding the value cells we talked about a few days ago, how do you represent the unbound state? using an internal symbol as a marker or something?
<makomo>
maybe you mentioned it as well, but i don't remember
FreeBirdLjj has joined #lisp
<beach>
makomo: Yes, it is per environment.
<Bike>
(declare (special ...)) is itself lexical. isn't that nice
<phoe>
there are features that are *not* in the keyword package
<phoe>
all pushed by third-party libraries...
<jackdaniel>
if you type #+flat-namespace , it will look in features for keyword:flat-namespace
<jackdaniel>
if you type #+cffi:flat-namespace, it will look in features for cffi:flat-namespace
<phoe>
ooh
<phoe>
#+CHIPZ-SYSTEM:GRAY-STREAMS
<phoe>
I understand it now - thanks
veinofsony has joined #lisp
<jdz>
Right, the correct wording is: «While reading the test, the current package is the KEYWORD package.»
lavaflow has joined #lisp
asarch has joined #lisp
eschatologist has joined #lisp
akovalenko` has joined #lisp
bradcomp has joined #lisp
akovalenko` has quit [Remote host closed the connection]
shlemas has quit [Quit: shlemas]
<oni-on-ion>
curious, what reason is tail-call optimisation excluded from CLTL?
<trittweiler>
It's not excluded as in prohibited, it's implementation-dependent
<phoe>
oni-on-ion: the ANSI CL standard doesn't mandate it
<phoe>
many implementations do TCO unless on high debug settings
<oni-on-ion>
ahh right, i see. its useful to not have it happening while debugging ?
<phoe>
yep - you want all calls on the stack
Copenhagen_Bram has quit [Ping timeout: 240 seconds]
cgay has joined #lisp
nika has joined #lisp
<oni-on-ion>
i also notice, that when slime is running, emacs will highlight the code i've changed. i've been disabling that as it gets a bit laggy the more of these highlighted regions there are, but i've just read in this article here that one can send all of those edited lines into slime. anyone know how off hand?
<oni-on-ion>
phoe: ah right ok =)
<phoe>
oni-on-ion: never experienced this highlighting behavior
<phoe>
you're running some kind of custom config?
<trittweiler>
Once upon a time, I was thinking of writing a small TAILCALL that would expand to the right declarations depending on the implementation (and otherwise cause compilation to fail.) Not sure if (locally (declare ..magic..) (funcall ...)) is enough on all implementation; an implementation may need optimization settings at the start of the body of the function.
<trittweiler>
oni-on-ion, it's the slime-highlighting-edits contrib. Just remove that from your (slime-setup '(...)) list
it3ration has joined #lisp
<trittweiler>
it would be nice to see if it can be sped up or where the bottleneck is, if you have the time anyway.
<oni-on-ion>
trittweiler: i will start using it now, because i find it useful if even there is no way to "eval all highlighted edits into slime connection"
<oni-on-ion>
i just read the whole elisp code for it, nothing seems obviously computationally demanding, i can only guess that multiple background faces make emacs slow on my system. will keep mind open on that
it3ration has quit [Ping timeout: 272 seconds]
gendl has joined #lisp
lnostdal has quit [Ping timeout: 244 seconds]
<AeroNotix>
I'm not sure I understand why TCO was left up to the implementation. Relying on TCO makes your code non-portable. At the time of standardization was TCO rare/difficult/something else?
<oni-on-ion>
would it affect some code to rely on TCO optimization? would that really change semantics etc?
<oni-on-ion>
that is also what i am thinking and just why i asked, AeroNotix , maybe TCO was undeveloped at the time
<AeroNotix>
wait no
<AeroNotix>
reading wiki suggests Guy Steele wrote a paper on it in '77.
<AeroNotix>
Further muddying why its mention is suspiciously absent from the standard
Hu0p has joined #lisp
<Bike>
the standard doesn't really mandate optimizations
<oni-on-ion>
i was going to say, just thought of scheme.. hmm.
<Bike>
so you can write pretty dumb implementations
<oni-on-ion>
fair enough reason, i cant see how tco would affect regular code though
<oni-on-ion>
heh, from a-road-to-common-lisp: "You don’t have to track down the bug from just a stack trace, like a detective trying to piece together what happened by the blood stains on the wall. You can examine the crime as it’s happening and intervene to save the victim."
Hu0p has quit [Ping timeout: 246 seconds]
<oni-on-ion>
ohh, extensive =)
regreg has quit [Quit: Konversation terminated!]
lnostdal has joined #lisp
Hu0p has joined #lisp
scymtym has quit [Ping timeout: 260 seconds]
doubledup has joined #lisp
akovalenko has joined #lisp
Lycurgus has quit [Quit: Exeunt]
Jesin has quit [Quit: Leaving]
papachan has quit [Ping timeout: 252 seconds]
scymtym has joined #lisp
Jesin has joined #lisp
MetaYan has quit [Ping timeout: 240 seconds]
wodwos has quit [Ping timeout: 244 seconds]
pjb has joined #lisp
<jasom>
oni-on-ion: also, dynamic bindings can make things that look like tail-calls not actually tail calls
<Bike>
"affect regular code"?
<pjb>
and unwind-protect if that has not been mentionned yet.
<oni-on-ion>
Bike: hm, code that doesnt somehow depend on TCO for its functionality
<oni-on-ion>
im not smart enough to imagine any but i wont make the assumption that such code is possible/exists/isbenefitial
<Bike>
like, almost all existing code?
<Bike>
i thought you were talking about making TCO non optional
<Bike>
meaning the implementation has to recognize tail calls
<oni-on-ion>
yes. well im trying to figure out if TCO affects the actual execution/result of code with and without it
<AeroNotix>
The link I provided before suggests that most major/non-meme CL implementations have TCO. I wonder how SBCL deals with a (funcall dynamically-bound-function) in the tail call position
<Bike>
sure it does, isn't that why you're asking?
<oni-on-ion>
or if code and/or algorithms could or would depend on it being present or not
<oni-on-ion>
Bike: so its not just an optimization? it changes the resultant code?
<Bike>
with TCO, it works. without, it can hit stack limits for high n
<Bike>
that's the entire reason scheme mandates TCO
<oni-on-ion>
ahhh. forgot about stack things. just read that the stack frame is gone before the call rather than after, when TCO is happening
<oni-on-ion>
+()
<Bike>
tco means reusing the stack frame
shka_ has quit [Ping timeout: 252 seconds]
<Bike>
if you're just talking about whether implementations CAN do TCO, there's nothing preventing it, and like aeronotix said it's pretty common
<oni-on-ion>
kk
<oni-on-ion>
yeah nah just wondering if tco affected the code (other than stack limit)
<AeroNotix>
I wonder how many libraries out there rely on TCO
<oni-on-ion>
its clear now ty for helping me understand
<oni-on-ion>
@all =)
<Bike>
lisp has other looping constructs, unlike scheme, and they're more commonly used
Bronsa has quit [Ping timeout: 240 seconds]
<AeroNotix>
Bike: the issue for me is that, yeah, CL has other looping constructs but if an implementation/most implementations implement TCO then what's the point if it's not a portable construct?
<Bike>
well, for example, my factorial function
lumm has quit [Remote host closed the connection]
<dlowe>
sbcl uses it depending on the speed optimization
<Bike>
practically speaking, you'd have to have n in the hundreds to bust up the stack
<Bike>
but if you feed a number that big to factorial it's going to be huge anyway
<Bike>
so it's fine to use most of the time
<Bike>
and if it is, with TCO it's more efficient
<AeroNotix>
Bike: but it's not portable, is my point
lumm has joined #lisp
<AeroNotix>
it's kind of "de facto" portable
josemanuel has joined #lisp
<Bike>
what i mean is if you treat it as an optimization it's not necessary for it to be portable
<|3b|>
well, arrays larger than 2^24 elements aren't portable either, but they are pretty useful too :)
<AeroNotix>
Bike: eh, I can agree with that but it still would make me uncomfortable about using it.
<AeroNotix>
For me, TCO is more than about being optimal.
<AeroNotix>
I find it cleans up some kinds of code to be more readable
<|3b|>
(or 2^16 technically, but 2^24 is a limit in actual implementations i can think of)
<|3b|>
TCO can be nice for state machines, which might be worth some non-portability
Hu0p has quit [Ping timeout: 240 seconds]
<Shinmera>
While we're on that, how about call-arguments-limit only being required to be 50
<AeroNotix>
Shinmera: do you find yourself hitting that limit often?
<Shinmera>
If you think you can just apply away you might
shka_ has joined #lisp
<|3b|>
yeah, not hard if you (mis)use apply where you should reduce
<Shinmera>
ABCL for instance has c-a-l on 50
* |3b|
has hit the "array indices are fixnums" a few times though, even on sbcl with relatively large fixnums, much less clisp with 24bit fixnums :)
<|3b|>
less of a problem since s3witching to 64bit though :)
m00natic has quit [Remote host closed the connection]
<phoe>
hey, no one requires arrays to be greater than a kilobyte
<pfdietz>
I get annoyed when I see something like (apply #'+ x) instead of use of reduce.
<|3b|>
that too :)
<shka_>
i added that error resignaling
<|3b|>
though i probably wouldn't expect much of anything to work on an implementation with A-T-S-L = 1024 :)
<shka_>
it is a bit lame because restarts won't work
<shka_>
but at least my pipe runs 165% of normal speed and now i can use it whenever i want it with just one line of code so that's nice
<shka_>
a little bit hackish, but i guess this makes it worth it
<pfdietz>
call-arguments-limit is 64 in gcl.
<pjb>
pfdietz: (unless (< (length x) call-arguments-limit) (apply #'+ x)) is good though.
<pjb>
pfdietz: not that big; it could be smaller, down to 50.
<pjb>
s/unless/when/ sorry.
<Shinmera>
As I said, ABCL has it on 50
<AeroNotix>
pjb: why is that good?
<pjb>
AeroNotix: because it's guarded :-)
<pjb>
with when.
<AeroNotix>
pjb: so it returns NIL instead?
<pjb>
AeroNotix: yes. Or you can write: (if (< (length x) call-arguments-limit) (apply #'+ x) (reduce #'+ x))
<AeroNotix>
pjb: why not just (reduce #'+ x) instead?
<pjb>
Because apply would be faster, and may give better results.
<AeroNotix>
What are those "better results"?
<AeroNotix>
If say, x is filled with floats or something?
<pjb>
apply may sort the arguments according to type or magnitude, so it may give more precise results than reduce.
<pfdietz>
Don't forget :initial-value 0
<pjb>
Yes, if (null x).
<pjb>
But it's actually not needed, because + takes 0 or 2 arguments.
<pjb>
(reduce #'+ '()) #| --> 0 |#
rumbler31 has joined #lisp
<pjb>
(reduce (lambda (a b)(+ a b)) '()) #| ERROR: Too few arguments in call to #<Anonymous Function #x302006ADAE4F>: 0 arguments provided, at least 2 required. |#
<pjb>
(reduce (lambda (a b)(+ a b)) '() :initial-value 0) #| --> 0 |#
<pfdietz>
(loop for x in y sum x)
<pjb>
same problem as with reduce.
rumbler31 has quit [Remote host closed the connection]
<|3b|>
if order matters, i'd probably rather have it consistent than break when you add 1 more item to list :)
<pjb>
Clearly, if you use reduce, you must sort your values.
<pjb>
And thankfully, file-position returns nil when it cannot seek; but it still can signal an error when the position is too big or inappropriate.
<jackdaniel>
example of file-stream which wouldn't be seekable is a posix fifo file
<pjb>
The problem here is that we don't know if (1+ pos) or (1- pos) are appropriate positions.
<pjb>
Not in ccl: (with-open-file (stream "/tmp/foo") (typep stream 'file-stream)) --> nil
<pjb>
By definition, a file-stream is seekable.
<pjb>
Even a tape would be seekable.
mrcom_ has quit [Quit: Leaving]
mrcom has joined #lisp
<jasom>
pjb: file n. a named entry in a file system, having an implementation-defined nature. <-- I disagree that a posix named fifo is not a file
<pjb>
That said, you're right that file-position only specifies a STREAM, so it could work on other type of streams, and it could be possible to find file-streams that are not seekable for soem reason.
<pjb>
Yes.
<pjb>
It can be implemented as such.
<jasom>
also open is required to return an object of type file stream
<pjb>
Notably: (with-open-file (stream "/tmp/foo") (pathname stream)) could return #P"/tmp/foo" for fifos.
<jasom>
though I'm not sure what is appropriate for (open a-stream-that-is-not-a-file-stream)
<jasom>
oh, if it's not a file stream, then it's also probably not a pathname designator
<pjb>
Indeed.
<jasom>
unless it's a synonym stream to a file-stream
<pjb>
And there are people who would like to write a new CL standard, when 22 years later, we still haven't debugged all the implementations!
<aeth>
pjb: A new standard would only help portability. Right now, there are SBCL-only libraries that don't need to be.
nowhere_man has joined #lisp
<dlowe>
I think a new standard would mostly be about removing things and making them more regular to make implementation simpler
edgar-rft has quit [Remote host closed the connection]
<aeth>
dlowe: The not very controversial things I'd like to see are (1) lower the minimum requirements for short-float so IEEE half-precision floating-point can be used (short float was originally meant for unboxed float in 32-bit implementations) and (2) raise the minimum requirements for most other things, which seemed to have been written with 16-bit in mind (e.g. the 1024 minimum array size, which includes string length)
<aeth>
Ideally, the minimums would be different for 32-bit and 64-bit implementations and the implementation would say in some standard way which set of minimums it is following. Then a library that needs the higher minimums could choose to only support the 64-bit one, for instance.
<pjb>
aeth: just patch an implementation to do it. And make it compatible with cuda for a big win.
<aeth>
And finally, it would be very useful for the specialized-arrays that (almost) everyone implements to be part of the standard, not just bit and character arrays. This means (unsigned-byte 8) and single-float and a minimum. Ideally double-float, too.
<aeth>
Even Scheme has byte arrays now.
<aeth>
pjb: shrinking short-float is absolutely done with CUDE/OpenCL in mind
<aeth>
*CUDA
<aeth>
pjb: Anyway, these little things don't need to be part of a new standard, they could be their own independent standard. And the non-conforming short-float could be hid behind a flag that defaults to NIL, like some of SBCL's non-conforming behavior is
<aeth>
s/hid/hidden/
kajo has joined #lisp
<jasom>
dlowe: I'd also like a few hooks in the reader. Several things that are proposed new features could be done in libraries if the reader were just slightly more flexible
<pjb>
Yep.
<pjb>
<pjb>
the readtable-parse-token hook.
<jasom>
yup
<jasom>
package-local-nicknames, for example is trivial with that.
* dlowe
sighs and opens a doc.
<dlowe>
I think package-local-nicknames should be a basic feature :p
SenasOzys has quit [Quit: Leaving]
<DGASAU>
jasom: "what is file" is very famous discussion that happened back in FTN days in RU.OS.CMP :)
<dlowe>
I also think that proposed new features are still valuable even if they potentially could be implemented in libraries
<dlowe>
primarily because they communicate "these features are your toolset and should be everywhere."
<jasom>
dlowe: I agree. If we are only going to add new standard features every 30ish years though, then perhaps we should make sure that the standard allows for implementing some of those features as portable libraries
<jasom>
.. should have been a "but" or "however" after "I agree" there.
<dlowe>
oh, absolutely
<dlowe>
I mean, you can just look at the people who prefer to use loop over iterate and see the power of the standard library
trocado has joined #lisp
<dlowe>
(I'm one of those people, though I like iterate in principle)
<jasom>
heh, I got a bad taste in my mouth because when iterate was introduced it used a very poorly written loop in one of its examples of why it is better than loop
<aeth>
I prefer to use anything in the standard other than loop if possible. I think collect is my main use of loop because I don't know of a simpler or even equivalent way to do it portably.
<jasom>
aeth: portably collect would be keeping a pointer to the tail of the list
<aeth>
Would be interesting to add a sexpy way to generate lists into the standard.
<aeth>
jasom: Yes, but once you're thinking about setfing the cdr of the list you're now writing something that's going to be at least twice as complicated, probably.
<aeth>
As much as I dislike loop, I'll use it when the alternative is more complicated.
<dlowe>
aeth: mapcan is often simpler
<aeth>
jasom: I've written that algorithm before for custom cons-like data structures and it's nowhere near as trivial as just using loop ... collect
<aeth>
(always keeping track of the last element)
<jasom>
yeah; off the top of my head: (let* ((head (cons nil nil)) (tail head)) (setf (cdr tail) (cons newitem nil) tail (cdr tail)) (cdr head))
orivej has joined #lisp
<aeth>
dlowe: Well, you can use the mapfoo for some, but not all, of the cases where collect works. They definitely won't work for e.g. collecting into two lists based on a conditional
<jasom>
shorter but perhaps less obvious using (list x) rather than (cons x nil)
Achylles has joined #lisp
<aeth>
here's something that's not *quite* trivial, but you need loop to make it even this simple afaik: (loop for i from 0 below 42 if (evenp i) collect i into evens else collect i into odds finally (return (values evens odds)))
<jasom>
Turning this into a macro wouldn't be too hard: (let* ((head (list nil)) (tail head)) (flet ((collect (item) (setf (cdr tail) (list item) tail (cdr tail)))) ... (cdr head))
<Xach>
there is a new quicklisp dist update this day
<slyrus1>
woo hoo!
<slyrus1>
new nibbles and ironclad, i hope?
<slyrus1>
scymtym: around?
trocado has quit [Read error: Connection reset by peer]
DGASAU has quit [Read error: Connection reset by peer]
DGASAU has joined #lisp
buffergn0me has joined #lisp
papachan has joined #lisp
vsync has joined #lisp
<vsync>
looking for more information about ASDF plans and why they be the way that it do
<vsync>
I'm building a system that has some similarity in terms of a hierarchical ordered set of operations and want to learn any lessons from it
<aeth>
jasom: What's probably needed is a library of minimal macros and/or higher order functions for iteration that look like they could have been in the standard. Most could be very trivial, e.g. do-hash-table (like dolist) is just a tiny wrapper on top of maphash
<aeth>
do-sequence could use map nil
<jasom>
I find loop to be 1000x more readable than dolist since I don't need to remember the order of parameters
<phoe>
jasom: oh boy, are you reinventing UIOP:WHILE-COLLECTING?
<vsync>
in particular why is a plan just a list of steps and not nested, and what were the tradeoffs of traverse to full depth before execute vs build a top level plan then go to execute and make little plans then
<vsync>
think I may have seen that before some time ago... it pleases me regardless
<vsync>
did you have a list of those bookmarked or is it embarrassingly like page 1 of Web search "planning things"
<pjb>
The later. Sorry.
<pjb>
My name is google.
<vsync>
oh well, maybe I should see if I was thinking over-specifically
<pjb>
Search. Google Search. :-)
_sfiguser has joined #lisp
<vsync>
and at least the simple-planners looks like I can shallowly exploit what I want quickly
<vsync>
and at least I found which page/doc of fare's I was thinking of
trocado has quit [Ping timeout: 252 seconds]
<_sfiguser>
hello all, which are alive lisp languages? is common lisp and scheme still active projects and viable options ?
<pjb>
vsync: well, you might have a look at the system construction systems, things like make, scons, maven, ants, etc. You might find some more specific algorithms.
<_sfiguser>
i want to start with lisp
<AeroNotix>
_sfiguser: define alive
<phoe>
_sfiguser: actively developed and used? yep, both CL and Scheme fall into that category
<Xach>
_sfiguser: common lisp and scheme are still active and developed and used.
<pjb>
But really, what you have is the description of a hopefully acyclic graph, with labelled nodes and edges, and you have to determine goals (from the current state of the file system or other objects (eg. compiled functions and source sexp in a lisp image).), and then build a plan to obtain those goals by flowing the graph util you reach only existing nodes.
<phoe>
you've wandered into #lisp - a Common Lisp territory
<vsync>
oh man, MK-DEFSYSTEM... total classic
igemnace has quit [Quit: WeeChat 2.2]
<pjb>
_sfiguser: yes, but here we will advise you to use Common Lisp, more survival stamina in there…
<_sfiguser>
pjb, what do you mean by survival stamina ?
<phoe>
fmakunbinding any symbol in CL is undefined behavior
<AeroNotix>
sure, I get that. Just gave me a chuckle
<phoe>
oh wait
<pjb>
_sfiguser: CL has older roots than scheme. It has more genes. It is and will be able to survive longer. Scheme is already at its 7th revision (ie. already 8 versions of the language!) while CL has a single standard and that's it.
<pjb>
_sfiguser: Furthermore, you can run in CL lisp programs that are more than 40 years old!
<phoe>
you kick five completely random functions/macros/specops out of the CL package
<pjb>
So my bet is that it will be able to run the programs you write today in 60 years. Enough until you die programming or until the singularity whichever occurs first.
<AeroNotix>
phoe: I'm sure it could break things that depend on them
<AeroNotix>
but would be a fun little diversion trying to patch things back up
<phoe>
AeroNotix: I don't think so
<phoe>
inside implementation-defined functionality, they're likely baked into the code
<phoe>
also (fmakunbound 'cl:if) doesn't do a thing (:
<phoe>
(at least on SBCL)
<_sfiguser>
pjb, what are modern famous pieces of software written in lisp ?
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<Bike>
irreplaceable?
<phoe>
Bike: if you accidentally (fmakunbound 'cl:handler-bind), other than it being UB, you have no portable means of reimplementing it
cage_ has quit [Quit: Leaving]
<Bike>
you could just reimplement the whole condition system
<Bike>
how about, function
<phoe>
hm
<phoe>
wouldn't (compile nil ...) be kiiiinda equivalent?
<phoe>
wait, that's for lambdas
<phoe>
for global functions, you have fdefinition
<phoe>
for local functions... hm
<phoe>
you can't really return closures without FUNCTION specop
<_sfiguser>
aeth, all of them done in lis p ?
<phoe>
_sfiguser: Franz is a Lisp vendor
<phoe>
would be pointless for them to promote something not made in Lisp as a Lisp success story
v0|d has joined #lisp
<pjb>
sjl: Well, for binary streams, input-stream-p is hard: you have to read a byte. For character streams, you can use peek-char.
<pjb>
Since there's no unread-byte…
<phoe>
sjl: what about my method?
<phoe>
uh I mean
<phoe>
pjb: ?
<pjb>
Yes, make-concatenated-stream is good.
it3ration has joined #lisp
<pjb>
I thought it would be lazy, but not, it's specified to signal the type-error.
vlatkoB has quit [Remote host closed the connection]
<sjl>
pjb: yeah not having peek-byte is unfortunate, but make-concatenated-stream would work
<aeth>
_sfiguser: Games generally use the host's OpenGL driver as well as some portability library like SDL to access windows/input/etc., so they can't really be done 100% in any language except C (and even that doesn't work because some drivers/libraries/etc. are C++)
<_sfiguser>
im just entering now the lisp world and everything seems cool
<_sfiguser>
what do you like about lisp that is not in other programming languages which are not lisp dialects ?
it3ration has quit [Ping timeout: 245 seconds]
<_sfiguser>
or what do you think may be the advantages ?
pierpa has joined #lisp
<oni-on-ion>
real live coding; ie. able to change everything in runtime, class definitions too. and real macros. the `, syntax is perfect for flipping modes which i think a lot of people dont realise is very important at least cognitively
<oni-on-ion>
Julia is my favorite, it is very close to perfect in most ways, it is a truly awesome language, but without those two specific things it can't be my number 1 tongue that lisp is
<oni-on-ion>
(for the current project)
Achylles has quit [Quit: Leaving]
rpg has joined #lisp
<jasom>
_sfiguser: SLIME is easily the most productive development environment I've used; really a focus on good development environments seems peculiar to the lisp and smalltalk communities
<jasom>
_sfiguser: Also, the language is malleable. I started using python in 2.2, and it's gotten a lot of useful features since then, but many of the things in python that had to be language features could be implemented as a library in lisp.
<shka_>
oni-on-ion: perhaps if i knew about folio before i would never start cl-ds
Blukunfando has joined #lisp
Roy_Fokker has joined #lisp
[X-Scale] has joined #lisp
mindCrime has quit [Ping timeout: 244 seconds]
doubledup has quit [Quit: Leaving]
<_sfiguser>
pjb, no but thankks for the resource...
<_sfiguser>
what is SLIME ?
<_sfiguser>
oh ok emacs
<_sfiguser>
i'm used to vim
<_sfiguser>
but i like emacs
X-Scale has quit [Ping timeout: 240 seconds]
[X-Scale] is now known as X-Scale
<_sfiguser>
the only thing i don't like is that since i'm used to vim i find editing slow in emacs
<shka_>
spacemacs is quick way for vimer to switch to emacs
<jasom>
_sfiguser: if you install evil-mode to emacs you are fairly vim compatible keystrokes
<_sfiguser>
shka_, really? why has it already the vi mode set ?
<_sfiguser>
jasom, ok i'll keep that in mind
<_sfiguser>
so clisp can also do concurrent stuff as clojure ?
<jasom>
_sfiguser: control-g intsead of escape is the only real difference at that point (i.e. C-g is what you want to do to cancel where you would hit escape in vim)
<shka_>
_sfiguser: it is a large cow, it has looooots of stuff
<shka_>
and during setup it allows you to choose vi style editing
<jasom>
_sfiguser: I prefer message-passing concurrency; IIRC clojure's is based upon STM; not sure if there is a library in lisp for it.
<shka_>
jasom: there is! for sbcl though
<_sfiguser>
lisp is also used for web programming and so on ?
<_sfiguser>
seems cool
orivej has quit [Ping timeout: 245 seconds]
<_sfiguser>
why they call it the programmable programming language ?
<jasom>
_sfiguser: pretty much everything is used for web programming today, since the web is kind of taking over the world
<shka_>
_sfiguser: you can turn lisp into something else
jeosol has joined #lisp
<jeosol>
morning guys
<jasom>
_sfiguser: you can easily make new control constructs in lisp, for example.
<shka_>
well, it is like common lisp is not programing language, but a building material
<_sfiguser>
shka_, what do you mean ?
<_sfiguser>
can you make an example in code for which something is really simple in lisp but owuld be complicated in other languages ?
<jasom>
python 2.2 did not have a with statement; you could not add it to python 2.2 with a library. Implementing a new statement like that in lisp is trivial
<shka_>
_sfiguser: well, it is difficult to explain, but mind set is that instead of writing something IN lisp you are writing it ON lisp
<aeth>
Does CLOS have alternatives to inheritance?
<shka_>
you made stuff that is essentially embedded into language
<shka_>
and oddly enough, lisp is sort of made this way
<shka_>
so most of lisp is actually written in lisp
<shka_>
it makes it very… bendable
<shka_>
aeth: what do you want to do?
<pjb>
aeth: you can just not include any superclass.
<aeth>
_sfiguser: CL has dolist but it doesn't have an equivalent for hash tables. That's as trivial as (defmacro do-hash-table ((key value hash-table &optional result) &body body) (let ((maphash `(maphash (lambda (,key ,value) ,@body) ,hash-table))) (if result `(progn ,maphash ,result) maphash)))
<aeth>
(It's harder than it would have been if dolist didn't have an optional return value for the result)
<shka_>
anyway, it is not even about macros
<pjb>
But you can avoid the test and always generate ,maphash ,result
Copenhagen_Bram has quit [Read error: Connection reset by peer]
<aeth>
Similarly, CL doesn't have something like foreach (unless you count loop as one), but you can implement a do-sequence as easily as (defmacro do-sequence ((var sequence &optional result) &body body) (let ((map-nil `(map nil (lambda (,variable) ,@body) ,sequence))) (if result `(progn ,map-nil ,result) map-nil)))
<aeth>
(I'd count do-sequence as a true foreach and not count dolist because do-sequence will work on every sequence like MAP does)
<_sfiguser>
aeth, to me your code seems very unreadable at the moment XD
<pjb>
What I find more regretable in the dolist etc macros, is that there's a result expression, but no provision to bind a result variable. So you often have to (let (result) (do… (var … result) …(setf result …)))
<Ober>
but for-each is typically reduced right?
<_sfiguser>
why do you say you don't write things in LISP bu ON LISP ?
<pjb>
in which case, it would be as well to write (let (result) (do… (var …) …(setf result …)) result)
<aeth>
pjb: yes
<aeth>
_sfiguser: It's mostly unreadable because it's in one line
<pjb>
of course, just copy and paste the expressions in an emacs lisp-mode buffer, insert a few new lines, and have emacs indent it.
<ym>
In what constraint logical programming system, implemented on top of CL I can use Prolog's CLPx libraries?
<shka_>
_sfiguser: kinda difficult to explain, but boils down to the fact that many lisp libs are more akin to language extensions
Copenhagen_Bram has joined #lisp
<shka_>
at least to some degree
<aeth>
_sfiguser: For trivial macros like this, you just need to understand quasiquotation. Sometimes you don't even need that. You could just have (defmacro foo (&rest forms) (some-function-that-takes-in-a-list-and-returns-a-list forms))
<pjb>
_sfiguser: the idea is that you make the language evolve toward your problem domain, at the same time you implement your solution, so in the end, your program is not so much written in CL as in a domain specific language implemented on CL.
<shka_>
postmodern, screamer, etc. are language extension to some degree
<shka_>
same for lparallel
<pjb>
_sfiguser: was soon as you write a macro, you're extending the programming language.
<pjb>
_sfiguser: and you can write macros, reader macros, and compiler macros in CL ! There are 3 different types of macros.
LiamH has quit [Quit: Leaving.]
<_sfiguser>
pjb, wow that seeems really interesting... so why lisp is not so popular ?
<_sfiguser>
nowadays
<_sfiguser>
i have to learn emacs
<_sfiguser>
and of course lisp
<ym>
Ok, thanks, now I want comparison between screamer and miniKanren.
<_sfiguser>
do you think structure and interpretation of computer programs can be still considered a modern book? or it explains old concepts ?
<shka_>
ym: those are different things
<russellw>
_sfiguser, still modern, because the concepts it explains are timeless fundamentals, like algebra
<ym>
shka_, on what level?
<aeth>
_sfiguser: Lisp isn't popular for the same reason Google+ or Diaspora isn't popular. Network effects matter.
<shka_>
ym: one is logic programming and stuff, the other is constraints programming and stuff
<aeth>
For a programming language that matters on multiple levels. Resources, tooling, training, jobs, libraries, etc.
<shka_>
logic programming is constraints programming, but with it's own twist
<shka_>
for instance, database
<ym>
I thought both implement CLP.
<ym>
And so able to handle algorithm database with some term algebra magic.
<ym>
Oh, I fount YouTube lecture about Screamer. Nice.
<_sfiguser>
AeroNotix, no i'm not, if i were like that i was not here... just keep into account industry
<oni-on-ion>
aeth: also i think that inheritence in CLOS is using before/after method chaining isnt it ? can be entirely customized but that 'inheritence' is just the default.
<_sfiguser>
and want to know what's the place of lisp
<aeth>
Note that some things are Lisp family but majority CL and some of these things are strictly Common Lisp.
<AeroNotix>
_sfiguser: my suggestion is just learn CL and discover what it means for you and what place you find it useful.
<aeth>
_sfiguser: The most active subcommunity online is probably the Lisp games community with the IRC channel #lispgames and with regular game jams on itch.io such as https://itch.io/jam/lisp-game-jam-2018
<aeth>
_sfiguser: Most commercial activity is probably websites, but #lispweb is a dead channel. I guess it's not as fun to talk about.
<oni-on-ion>
lots of nice CL web frameworks though. radiance, weblocks, cowboy2 .... hunchentoot, cl-who, etc..
<aeth>
The wiki can also be useful but it's a mix of up-to-date and things that are 10 years out of date ime. https://cliki.net/
<AeroNotix>
and using lisp for web programming just seems an absolute waste, too. I think it was David Nolen who said "give someone the most powerful programming language and they'll make a web framework"
sjl has quit [Ping timeout: 250 seconds]
<oni-on-ion>
i think CL is great for web programming. especially not having to restart the server, and a lot of work with textual data.
<no-defun-allowed>
Ooh, story time.
<no-defun-allowed>
I was working with a lisp web server once.
<AeroNotix>
sure, it's a reasonable language to do it in but I dunno, feels like a disservice to the language/environment if having lots of web frameworks is a selling point
<no-defun-allowed>
I'd run SBCL through tmux and rlwrap and copy paste fixes in. Now I know about remote SLIME but it worked
<oni-on-ion>
'having lots of web frameworks as a selling point' ? maybe i am missing something herre. =)
<aeth>
Lisp is great at generating strings from s-expressions and using that as essentially an alternative to templates (e.g. for XML, HTML, CSS, JSON, SQL, and even JavaScript)
<aeth>
(several GLSL, too)
Bike has quit [Ping timeout: 252 seconds]
<oni-on-ion>
im going to run the lisp image on my tablet win7.1 for gfx but i will use my desktop to swank/slime it from there. so its like having two screens. fwiw ^_^
<no-defun-allowed>
It was very easy using format to convert internal data formats into text and html. Very pleasant experience.
<oni-on-ion>
aeth yea =)
<no-defun-allowed>
The server would also write out s expressions to a file to backup proxy lists.
<AeroNotix>
oni-on-ion: your the one who mentioned all the web frameworks :)
Copenhagen_Bram has joined #lisp
<oni-on-ion>
if i really had to choose something else for webdev i would do node.js, but erlang or prolog for hardcore server stuff. i would choose CL for web sites and pages for sure. haskell was fun tho that one time =)
<oni-on-ion>
no-defun-allowed awesome ^_^
<no-defun-allowed>
Talking about it isn't doing it justice.
<oni-on-ion>
AeroNotix: perhaps i should have aimed at aeth, now im not sure, i thought you talked about it first for some reason =)
<no-defun-allowed>
Look under bot/ for the server.
<no-defun-allowed>
Adding authentication was one time where lisp shined, I just wrapped everything in a with-authentication macro which checked for a cookie, or directed the user to log in.
<AeroNotix>
oni-on-ion: I wouldn't have talked about web frameworks.
<oni-on-ion>
"<AeroNotix> using lisp for web programming .... "
asarch has quit [Quit: Leaving]
<oni-on-ion>
thats what i was responding to. thats all =)
<no-defun-allowed>
The bot uses hunchentoot for serving, drakma for remote calls, mini.css for aesthetics and some other stuff too.
<AeroNotix>
oni-on-ion: because YOU mentioned frameworks?
dented42 has joined #lisp
<no-defun-allowed>
A list used as a stack was how the bot got big IMO.
<no-defun-allowed>
If you had a queue and something went wrong, the erroneous request would go to the back of the queue. The Lisp bot would put it to the front of the stack (just with CONS) which was much nicer given we're drawing pixels on a game board as quickly as possible.
Jachy has joined #lisp
<Jachy>
Do many people put their lisp webservers behind apache with mod_proxy (or nginx)?
<aeth>
You absolutely shouldn't expose a Lisp web server directly to the public imo.
<oni-on-ion>
AeroNotix: eh wot? i mentioned them after i read your comment about lisp web dev. idk homie
it3ration has joined #lisp
<jasom>
I run behind mongrel2, but I'm the only one that does that AFAIK
kajo has joined #lisp
<no-defun-allowed>
Yes, that steaming pile of shit, oni-on-ion
<Jachy>
aeth: I feel the same
<no-defun-allowed>
Redpixel had burnt me out in the end. Fuck them.
<oni-on-ion>
AeroNotix: nah i guess not. my bad; it should have indeed been aimed at aeth , my apologies
<oni-on-ion>
no-defun-allowed: but the art! =)
<no-defun-allowed>
I had to maintain a bot managing several bases and I only got to use it a few times to make the stupid ancap base say things like "USE EMACS" instead of "BUY BITCOIN"
<no-defun-allowed>
It's full of Nazis and 4channers. Enough said.
<AeroNotix>
oni-on-ion: np
<oni-on-ion>
no-defun-allowed: didnt realise that many are probably automating their efforts. hm. i remember the initial version from HN sometime ago
<oni-on-ion>
no-defun-allowed: aha =)
<no-defun-allowed>
There are very many bots.
<no-defun-allowed>
Some are more sophisticated, outsourcing captcha solving and whatnot.
<Jachy>
There must be some people who run under jetty/tomcat with abcl too..
<no-defun-allowed>
My bot exposes an API for getting captcha tokens and also one for using a specific service too. We decided against using a captcha service cause they got expensive quickly and they weren't very humane.
<AeroNotix>
no-defun-allowed: humane?
<oni-on-ion>
eh smart tho, captcha solving =) i often forget how cunning we are.
<no-defun-allowed>
I have been experimenting with using pocketsphinx to solve audio captchas but it needs further training, and I'm getting into offtopic.
<AeroNotix>
"no captchas were harmed in the making of this sexp"
<no-defun-allowed>
AeroNotix: captcha solvers recruit third world people and pay em peanuts.
<no-defun-allowed>
They didn't seem to kind about how they kicked people out either.
it3ration has quit [Ping timeout: 246 seconds]
random-nick has quit [Ping timeout: 246 seconds]
<oni-on-ion>
chinese clickfarms are shops with walls full of connected registered cell phones. buy mindshare
<Jachy>
Some people in the states probably too, doubt mechanical turk cares much where you're from.
<aeth>
[image] please enter the numbers in this image to prove that you're not a bot and continue using IRC
<no-defun-allowed>
This is as far as I'm going to talk about captchas. Back to Lisp on the web thanks.
<AeroNotix>
no-defun-allowed: I'm aware of those but are you saying you didn't include captchas on a service you expose because you knew people would use clickfarms against them?
<aeth>
(I actually had that happen to me earlier today, where there was no image)
<no-defun-allowed>
AeroNotix: we had to clear captchas ourselves for the linked bot to work effectively we didn't want to support clickfarms.
<no-defun-allowed>
Occasionally the server will request a captcha token, so we take one from a queue that's not too old.
<AeroNotix>
no-defun-allowed: ok
<no-defun-allowed>
We did use a two queue system for a service but that got expensive: $30 for the first day.
<_sfiguser>
AeroNotix, aeth thanks for all th great suggestion
<no-defun-allowed>
The bot in its final days controlled more than 2000 proxies on one server without breaking a sweat (as measured by htop).
<no-defun-allowed>
Try doing that with python.
<_sfiguser>
you are a very nice community
<AeroNotix>
no-defun-allowed: what does "controlling a proxy" in this bot mean?
<no-defun-allowed>
AeroNotix: it send requests out through several http proxies.
<_sfiguser>
also i think i should start learning emacs
<AeroNotix>
no-defun-allowed: right so it's an online game that allows you set a pixel or something and you were using a suite of bots to bypass rate limiting?
<no-defun-allowed>
Yes.
<AeroNotix>
ok
<no-defun-allowed>
So yes, lisp helped the bot certainly get big. Stacks are more aesthetically pleasing and lisp (on portacle) was much easier to set up.
<AeroNotix>
I'd've used multiple IPs but that's just me
<AeroNotix>
no idea why a proxy is required
jerme_ has joined #lisp
<_sfiguser>
where is the development of common lisp done ?
<pjb>
_sfiguser: in the head of lisp programmers.
<_sfiguser>
like do the community have a github repo ?
<_sfiguser>
pjb, i mean source code
<pjb>
_sfiguser: sometimes, in the head of C programmers.
<pjb>
a lot on github, gitlab, a few remaining on sourceforge.
<pjb>
common-lisp.net has a gitlab.
<pjb>
Some remain in svn!
<AeroNotix>
_sfiguser: implementations of lisp or applications written on those implementations?
<no-defun-allowed>
Does oclcl support windows?
orivej has joined #lisp
varjag has quit [Read error: Connection reset by peer]
<_sfiguser>
AeroNotix, common lisp interpreter/compiler i meant
<AeroNotix>
_sfiguser: arguably the most popular implementation is sbcl, its development is over at https://github.com/sbcl/sbcl
light2yellow has quit [Quit: light2yellow]
<AeroNotix>
oh I guess that's a mirror actually
<no-defun-allowed>
sbcl.org
<aeth>
AeroNotix: I don't think it's really arguable except that we don't have exact data.
<aeth>
SBCL is much more popular than CCL which is much more popular than any of the rest. The only thing that would be hard to determine is what the #3 implementation is.
<AeroNotix>
aeth: you mean that you're more sure that it is the most popular or that it isn't?
<_sfiguser>
AeroNotix, so they don't develop clisp anymore ?
<aeth>
AeroNotix: It does match my expectations that SBCL is 10x CCL which is 10x the rest and you probably can't distinguish between the rest. Well, 10x seems a bit large for SBCL vs. CCL. I wouldn't be surprised if you did a survey of #lisp and it's only 3x more popular
<aeth>
But I would suspect that if you used many different ways to get incomplete data, you'd probably wind up with SBCL at #1 and CCL at #2. They're the fastest and they have the most helpful errors.
<aeth>
CLISP in 3rd wouldn't surprise me because so many outdated resources from more than 10 years ago recommended CLISP
<no-defun-allowed>
cough Land of Lisp cough
<aeth>
It's a shame that it'd probably be CLISP or a commercial Lisp in third because ECL really deserves the bronze medal there.
<Jachy>
How popular do each of the commercial lisps need to be to keep the companies afloat?
<aeth>
Jachy: If you're running something like Allegro or LispWorks you only really need one customer.
josemanuel has quit [Quit: leaving]
White_Flame has quit [Quit: No Ping reply in 180 seconds.]
<Jachy>
I mean e.g. Franz themselves, the ROI for you as a licensee is fast.
<aeth>
The people who do enterprise software love it because your customers are in the dozens instead of the millions.
White_Flame has joined #lisp
<aeth>
Jachy: I mean if you're running a custom programming language project.
<Jachy>
But they're not even on annual subscription models like the rest seem to be, so I wonder how many licenses Franz needs to sell per year to stay healthy.
<aeth>
They're not subscriptions? Strange.
<Jachy>
You pay again for upgrades.
<aeth>
You generally want subscriptions.
<aeth>
I suspect they'll simply switch their business model to a subscription one if they start to have trouble.
<Jachy>
Yeah, I think IntelliJ boosted their revenue quite a bit moving to that model.
<aeth>
_sfiguser: CLISP is still being developed, but it is not actively developed to the point where they are pushing out new releases regularly. I think it has been at least 5 years since its last release. It's imo very far behind a more modern implementation at this point because of all of the optional things and extensions that an implementation like SBCL or CCL supports these days.
<aeth>
I think lots of libraries at this point use at least one dependency that doesn't support CLISP.
<AeroNotix>
what is Scienteer lisp? Googling about now there's quite a lot of dead links for it
<pjb>
It was an expensive high performance commercial implementation. notice that commercial software is out of topic on freenode.
<Jachy>
AeroNotix: IIRC that was a multi-core spinoff from CMUCL.
orivej has quit [Ping timeout: 240 seconds]
<Jachy>
Is OpenLisp/ISLisp popular at all in europe?
<pjb>
I don't know of any program written in it. There are more than one implementation though.
<_sfiguser>
AeroNotix, what do you mean that is very far behind a more modern implementation? i mean does it lack stuff to make it a modern language ?
<AeroNotix>
pjb: sorry I just saw a reference to it in the quicklisp statistics linked above, had a question, asked a queston
<_sfiguser>
i mean is it considered a non viable dead language
<AeroNotix>
_sfiguser: I didn't say that
dale has quit [Quit: dale]
<_sfiguser>
AeroNotix, sorry i wanted to call AeroNotix
<AeroNotix>
again
<pjb>
AeroNotix: My answer was to Jachy's question.
<_sfiguser>
again... aeth
<AeroNotix>
pjb: > notice that commercial software is out of topic on freenode.
<pjb>
ok.
<AeroNotix>
that's what I was referring to
<AeroNotix>
_sfiguser: I'll try to offer an answer
<aeth>
_sfiguser: There are lots of optional things in CL implementations that CLISP does not support, such as (afaik) single-float and double-float arrays, type checking in places where it is optional, and various popular extensions that are handled in portability libraries (you only really find out this third category if you try to test a large Lisp application in an unpopular implementation)
<AeroNotix>
oh wait, ^^ never mind
<aeth>
(The standard afaik only requires type checking in CHECK-TYPE or ASSERT with a typep)
quazimodo has quit [Ping timeout: 252 seconds]
<AeroNotix>
and to be clear CLISP is a single implementation of common lisp out of many
<aeth>
Yes, that's the unforgivable thing, making a confusing name that makes it sound like it's a way of talking about the language. It's like if a C compiler was called Cee.
<aeth>
_sfiguser: On the other hand, CLISP does have some extensions that no one else supports, like arbitrary precision floating point.
* vsync
would never have thought of CLISP as abbreviation for Common Lisp.... seems obviously different
<vsync>
I assumed it was written in C or they liked the letter C or something
quazimodo has joined #lisp
* vsync
used to be inordinately fond of CLISP, probably cuz of trying to run on odd architectures in the days when the choice was that or CMUCL and have fun bootstrapping CMUCL
<vsync>
haven't run it in a while... sometimes install it just so I can see the menorah for nostalgia
<pjb>
clisp is not an abbreviation of Common LISP, but of C lisp. Ie. a lisp implemented in C.
<vsync>
feels like I should care more about running different implementations but don't really
<vsync>
zactly
<_sfiguser>
any good extension to do data analysis in lisp ? like managing csv files cleaning data or machine learning?
<_sfiguser>
i come from a python background and work with data science that's why i'm asking
<aeth>
pjb: Yes, but enough people try to use clisp instead of cl as an abbreviation for Common Lisp so that makes me think that the name itself is problematic.
<Jachy>
Once I confused clisp with GCL. Clisp calls itself "gnu clisp" on its home page too, but it's not gnu common lisp.
<vsync>
that was because of readline
pierpal has quit [Ping timeout: 252 seconds]
<aeth>
Jachy: GNU has Emacs Lisp, two Common Lisps (CLISP and GCL), and at least three Schemes (Guile, Kawa, and MIT/GNU Scheme). That's not confusing at all.
<vsync>
then I think it got adopted
trocado has joined #lisp
<_sfiguser>
guys are there collection of exercises i can do to practice lisp ?
<aeth>
I did some of the https://projecteuler.net/ problems in Lisp but that's more about cleverly solving the problem mathematically/algorithmically than learning a language.
<vsync>
_sfiguser: I think many of the textbooks have exercises
<aeth>
Google has https://github.com/google/lisp-koans but I bet they're in a slightly archaic style because programming languages, even ones with no revision to the standard since 1994, change what's idiomatic over time
fikka has joined #lisp
<aeth>
(An example of a style change over time: SETQ used to be about as popular as SETF, but SETF has clearly won at this point.)
<aeth>
(There are probably a few more that I'm missing.)
<aeth>
Jachy: I'd be careful linking to awesome-cl. It's not curated
<pjb>
So it's Common Lisp, COMMON-LISP or CL, or ANSI Common Lisp, or perhaps X3J13 ;-)
joast has quit [Quit: Leaving.]
<aeth>
Jachy: It seems to pretty much be a random list of things that people have submitted rather than something opinionated that someone new to CL should read.
joast has joined #lisp
<pjb>
So, it's lisp eternal september starting today? :-)
<Jachy>
aeth: It's curated, just not with any quality control, so definitely a buyer-beware.
<aeth>
pjb: Or you can call it "Lisp" if you want to annoy Schemers
<pjb>
Notice that in pre-standard, there was also a nickname "LISP" for that package :-)
<vsync>
guis I got assigned CLisp and how do I write a LISP recursion plz
Lycurgus has joined #lisp
<aeth>
vsync: Lisp doesn't do recursion, you want Scheme for that.
<aeth>
/s
<pjb>
vsync: like in any other programming language: by testing for the base case, and calling the function recursively in the general case.
<aeth>
pjb: I'm pretty sure vsync was joking
<pjb>
I know, but I amuse myself answering seriously to jokes.
<AeroNotix>
aeth: I'm pretty sure pjb was trying to joke as well
<AeroNotix>
The french sense of humour is much like the german's
<pjb>
Perhaps not in general, but I come from Lorraine, near Luxembourg and Germany.
<no-defun-allowed>
vsync: you must get one lisp and put it in the other lisp but then the first lisp must also be in the second lisp
<pjb>
In my father's village, in WWII when the germans arrived, they aligne people, and asked who wanted to be German and who wanted to stay French. All but two went for German (my grandfather stayed French).
<Bike>
hello.
<Ober>
yeah mine died fighting the Vichy french in NA
<pjb>
The lesson is that in Alsace-Lorraine, smart people know that it doesn't matter which, Berlin or Paris, they'll have to pay taxes all the same, so let's not contradict the current adminstration.
<aeth>
pjb: The lesson is that if I want to conquer anything I should start with Alsace-Lorraine, I guess.
<pjb>
Don't be so sure. We know the German, and we know the French (we're both), but it may be a different story with different people.
<aeth>
pjb: Well I'd conquer Alasce-Lorraine for Luxembourg
<pjb>
:-)
<pjb>
I'd be surprised if Luxembourg would want that :-)