<fwoaroof[m]>
Those are, at least, both extensible in a standardized fashion
<fwoaroof[m]>
Some LOOP implementations can be extended, but that's not specified in the standard
<sveit>
i know about iterate, but i think series is much more elegant and powerful (here the elegance is in the using, not the implementation :)). i probably will try to fork/maintain when life calms down a bit :) for now i just have my list of bugs.
<fwoaroof[m]>
As I said before, I think transducers are a better fit for lisp
<fwoaroof[m]>
SERIES relies on the ability to inspect declarations and do compile-time transforms, which I believe relies on either environment introspection or a code-walker
markong has quit [Ping timeout: 265 seconds]
<fwoaroof[m]>
Both of those are a bit tricky to get right
Fare has quit [Ping timeout: 260 seconds]
<fwoaroof[m]>
Transducers are pretty straight-forward to implement "in userspace" and are basically equivalent, from a composition/reusability perspective
<sveit>
sorry, i am not very familiar with transducers, are they not "series"?
<fwoaroof[m]>
Basically, the idea is you have MAP/FILTER/REDUCE return functions that take a continuation
<fwoaroof[m]>
And you have another function that takes such functions and injects a function that builds up a result
<sveit>
fwoaroof[m]: i see. is SBCL magical enough that this performs comparably to series/loop?
<fwoaroof[m]>
I haven't attempted to benchmark it
<fwoaroof[m]>
In most cases, though, I expect it to be significantly faster than map/remove-if-not/etc., once your collections get significantly large
<fwoaroof[m]>
Because you're no longer building up intermediate collections
<fwoaroof[m]>
I think, in most cases, the performance difference with series/loop either doesn't matter because the collections are small, or doesn't matter because your code is more modular
shifty has quit [Ping timeout: 240 seconds]
Fare has joined #lisp
<sveit>
yeah, the point of comparison is really series/loop, since the former works very hard to not build up intermediate collections, and in the latter you ensure this manually. i wonder more for the case of something like a nested loops over floats where you skip certain elements based on a predicate, otherwise call some function with side-effects on the float. the series case is as fast as a handwritten loop.
<fwoaroof[m]>
I suspect compiler macros for ALEXANDRIA:COMPOSE and for these functions can solve most of the performance issues
<sveit>
with enough inlining i would believe sbcl makes your continuation approach comparable, but i would have to check
<sveit>
fwoaroof[m]: agreed. i'll look into it, thanks!
<fwoaroof[m]>
I just think that the benefit of being able to use MAP/FILTER/REDUCE without intermediate collections and without compiler magic usually outweighs the performance difference
<fwoaroof[m]>
But, I'm generally on the expressiveness side of the performance vs. expressiveness debate :)
<fwoaroof[m]>
In theory, it's only different from SERIES/LOOP by a constant factor
<fwoaroof[m]>
Which is dominated by the overhead of calling a closure in your implementation of choice
<sveit>
i usually fall on the performance side, but everyone i know that does software in a serious way is the opposite of me and like you, so i am slowly learning :)
<fwoaroof[m]>
I think from a cost standpoint, it's usually less expensive for a company to buy extra hardware rather than making their programmers less efficient
<sveit>
fwoaroof[m]: but despite it being a micro-optimization, i really do think in tight (numerical) loops it's worth getting rid of that closure. i basically think of series in this "transducer" way, but with lots of optimizations to remove function calls and fuse loops. and a couple of bugs :)
<fwoaroof[m]>
Yeah, for some of those cases I think something like that is better
<sveit>
the other neat thing is if you are processing several series in parallel or use them more than once, it will tend to figure out how to loop over the series just once. for example, reasonable code to compute the mean and length of a series, which look like separate loops over a series, are compiled to a single loop.
<sveit>
i think it might be tricky to do this outside of the series approach, but maybe it's not even worth it to fuse the loops like this. apparently some hardware and compilers will de-fuse loops in fact :)
<fwoaroof[m]>
I use transducers in Clojure all the time for work, and I think they're one of the best parts of the language.
penguwin has quit [Quit: NO CARRIER]
<fwoaroof[m]>
I should look into how series is implemented, though: it feels like a bad sort of magic, which has always put me off using it
penguwin has joined #lisp
v88m has joined #lisp
<fwoaroof[m]>
The license of petalisp (AGPL3) is unfortunate, but it might also be relevant?
<sveit>
fwoaroof[m]: the code is not too pleasant imo, but if you start looking at it/using it feel free to ping me again, like i said i have at least one trivial bugfix and can tell you what to avoid to keep series happy
cc has joined #lisp
cc is now known as Guest67926
Guest67926 is now known as _cc_
nicktick has joined #lisp
ebrasca has quit [Remote host closed the connection]
__jrjsmrtn__ has joined #lisp
_jrjsmrtn has quit [Ping timeout: 246 seconds]
Bourne` has joined #lisp
Bourne has quit [Ping timeout: 240 seconds]
micro has quit [Remote host closed the connection]
libertyprime has joined #lisp
sjl_ has quit [Ping timeout: 260 seconds]
cosimone has quit [Quit: Quit.]
nicktick has quit [Ping timeout: 240 seconds]
nicktick has joined #lisp
c_nix has quit [Remote host closed the connection]
bhartrihari has left #lisp ["Disconnected: closed"]
bhartrihari has joined #lisp
EvW1 has quit [Ping timeout: 244 seconds]
libertyprime has quit [Quit: leaving]
ldb has joined #lisp
<ldb>
good morning everyone
nicktick has quit [Ping timeout: 240 seconds]
nicktick has joined #lisp
Bourne` has quit [Ping timeout: 264 seconds]
countvajhula has quit [Ping timeout: 260 seconds]
countvajhula has joined #lisp
bhartrihari has left #lisp ["Disconnected: closed"]
orivej has quit [Quit: No Ping reply in 180 seconds.]
shifty has quit [Ping timeout: 265 seconds]
ldb has quit [Ping timeout: 264 seconds]
shifty has joined #lisp
orivej has joined #lisp
v3ga has quit [Read error: Connection reset by peer]
v3ga has joined #lisp
tempusfugitful has quit []
ldb has joined #lisp
xrash has joined #lisp
akoana has left #lisp ["Leaving"]
orivej has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
caltelt has quit [Ping timeout: 240 seconds]
rumbler31 has quit [Ping timeout: 256 seconds]
space_otter has joined #lisp
Lycurgus has joined #lisp
Alfr_ has joined #lisp
Alfr has quit [Ping timeout: 260 seconds]
xkapastel has quit [Quit: Connection closed for inactivity]
epony has quit [Remote host closed the connection]
_cc_ has quit [Remote host closed the connection]
shifty has quit [Ping timeout: 264 seconds]
shifty has joined #lisp
countvajhula has joined #lisp
lucasb has quit [Quit: Connection closed for inactivity]
shifty has quit [Ping timeout: 246 seconds]
shifty has joined #lisp
countvajhula has quit [Remote host closed the connection]
countvajhula has joined #lisp
<beach>
Good morning everyone!
ldb has quit [Ping timeout: 264 seconds]
Lycurgus has quit [Remote host closed the connection]
abhixec has joined #lisp
countvajhula has quit [Remote host closed the connection]
countvajhula has joined #lisp
countvajhula has quit [Remote host closed the connection]
countvajhula has joined #lisp
orivej has quit [Quit: No Ping reply in 180 seconds.]
countvajhula has quit [Remote host closed the connection]
epony has joined #lisp
orivej has joined #lisp
countvajhula has joined #lisp
EvW has quit [Ping timeout: 260 seconds]
countvajhula has quit [Remote host closed the connection]
countvajhula has joined #lisp
countvajhula has quit [Remote host closed the connection]
countvajhula has joined #lisp
<Oladon>
Morning, beach!
countvajhula has quit [Remote host closed the connection]
countvajhula has joined #lisp
orivej has quit [Read error: Connection reset by peer]
orivej_ has joined #lisp
Lord_of_Life_ has joined #lisp
Bike has quit [Quit: leaving]
countvajhula has quit [Remote host closed the connection]
countvajhula has joined #lisp
Lord_of_Life has quit [Ping timeout: 256 seconds]
Lord_of_Life_ is now known as Lord_of_Life
jibanes has quit [Ping timeout: 240 seconds]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
oni-on-ion has quit [Ping timeout: 244 seconds]
jibanes has joined #lisp
Guest47874 has quit [Quit: Leaving]
zymurgy has quit [Quit: WeeChat 1.4]
gravicappa has joined #lisp
pfr has joined #lisp
torbo has quit [Remote host closed the connection]
zaquest has quit [Quit: Leaving]
orivej_ has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
micro has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
orivej has quit [Ping timeout: 264 seconds]
zaquest has joined #lisp
hendursaga has quit [Ping timeout: 240 seconds]
mindCrime has quit [Ping timeout: 260 seconds]
narimiran has joined #lisp
oni-on-ion has joined #lisp
oni-on-ion has quit [Ping timeout: 256 seconds]
mankaev has quit [Ping timeout: 244 seconds]
mankaev has joined #lisp
v3ga has quit [Read error: Connection reset by peer]
<flip214>
Does anyone know why some HN nick names are colored green?
shifty has quit [Ping timeout: 264 seconds]
nullheroes has quit [Quit: WeeChat 2.9]
nullheroes has joined #lisp
countvajhula has quit [Ping timeout: 244 seconds]
<edgar-rft>
I'm afraid this will remain one of the unsolved mysteries nobody wants to know :-)
jibanes has quit [Ping timeout: 256 seconds]
zymurgy has joined #lisp
jibanes has joined #lisp
gravicappa has quit [Ping timeout: 246 seconds]
bocaneri has joined #lisp
countvajhula has joined #lisp
Fare has quit [Quit: Leaving]
GreaseMonkey has quit [Quit: HYDRA IRC LOL]
bsd4me has quit [Quit: Leaving]
McParen has joined #lisp
Oladon has quit [Quit: Leaving.]
treflip has joined #lisp
<McParen>
hello, is there a usual way to add additional documentation to an inherited slot in a subclass?
<McParen>
At the moment, I add all the inherited slots and the new docstring, but that leads to quite a mess, because it is hard to see what slots are new and which are inherited.
space_otter has quit [Ping timeout: 240 seconds]
space_otter has joined #lisp
gaqwas has joined #lisp
pve has joined #lisp
<phoe>
flip214: they're new
space_otter has quit [Ping timeout: 240 seconds]
nirved has quit [Ping timeout: 240 seconds]
nirved has joined #lisp
<flip214>
phoe: ah, so "be gentle"? thanks
space_otter has joined #lisp
<phoe>
it's more like "be gentle" and "be wary" combined, given the repute that Hacker News comments section have
liberliver has joined #lisp
space_otter has quit [Ping timeout: 246 seconds]
countvajhula has quit [Remote host closed the connection]
countvajhula has joined #lisp
vaporatorius__ has quit [Read error: Connection reset by peer]
vaporatorius__ has joined #lisp
shifty has joined #lisp
countvajhula has quit [Ping timeout: 244 seconds]
space_otter has joined #lisp
ggole has joined #lisp
gaqwas has quit [Remote host closed the connection]
treflip has quit [Quit: WeeChat 2.6]
yaji has joined #lisp
greaser|q has joined #lisp
mokulus has joined #lisp
yaji has quit [Client Quit]
treflip has joined #lisp
<beach>
McParen: I don't know the answer to your question, but it is a bit strange to want to document a slot.
<beach>
McParen: Slots are implementation details, so the only person interested in the role of a slot would be the person reading the code, and then a comment is the appropriate way to describe what the slot is for.
countvajhula has joined #lisp
<flip214>
beach: can autogenerated accessor functions be documented via DEFCLASS?
<phoe>
flip214: I'd DEFGENERIC :DOCUMENTATION them myself
<phoe>
(which would be better for the protocol, anyway)
<phoe>
then DEFCLASS will just slap methods on top of these functions.
<beach>
flip214: I don't know, but you should always do the DEFGENERIC in my opinion.
<beach>
What phoe said.
<flip214>
yeah, thanks
<beach>
Just having a lambda list that you determined yourself, as opposed to OBJECT is worth it.
<flip214>
right, no need to do (SETF (documentation ...))
countvajhula has quit [Ping timeout: 244 seconds]
<beach>
Well, you may want to use that one anyway, since the documentation is not meant for the same category of people who read the code.
<beach>
So the documentation in a DEFGENERIC or DEFUN is noise to the maintainer.
<flip214>
beach: ah, thanks. that reminds me - I've got a patch in the pipeline so that in sbcl the accessors use the class name instead of INSTANCE.
<beach>
That's a tad better, sure.
<beach>
But what do you do for the first parameter of a slot writer.
<beach>
?
gaqwas has joined #lisp
gaqwas has joined #lisp
gaqwas has quit [Changing host]
<McParen>
beach: What would be the appropriate place to document functionality for the users of a library?
<McParen>
beach: So that, for example, it can be looked up on quickdocs.
<beach>
McParen: Users/clients should not know about slots. For such a person, a class should be defined by its initargs and its accessors.
<beach>
Quickdocs is an aberration. Documentation can not be generated from documentation strings.
<flip214>
that's still VALUE.
<phoe>
or NEW-VALUE mayhaps
<flip214>
beach: I guess we need something like doxygen, to parse documentation from comments.
<fe[nl]ix>
beach: I'd be extremely grateful if you could point me to an actual documentation system
<phoe>
McParen: you could take a look at Shinmera's documentation-utils
Duuqnd has joined #lisp
<beach>
It is not added value if a user starts using internal features that happened to be automatically documented, but that may disappear in the future.
<flip214>
phoe: VALUE kept the patch smaller.
<phoe>
flip214: four bytes saved
<beach>
flip214: That's the absolute wrong thing to do.
<fe[nl]ix>
I too rejected docstring-based systems, but now I'm in want of something better
<beach>
flip214: Like I said, comments are meant for the maintainer and documentation strings for the user/client.
<fe[nl]ix>
I settled on manually writing Markdown, but I get no help with cross-refs
<fe[nl]ix>
it's tedious
<McParen>
phoe: I'll look it up, thanks.
<beach>
fe[nl]ix: We might want to aim for something inspired by Concordia.
<phoe>
documentation-utils is a wrapper over SETF DOCUMENTATION
<phoe>
so that still deals with docstrings
<phoe>
anything that is not based on docstrings or comments is the problem that fe[nl]ix and beach are discussing at the moment.
<beach>
fe[nl]ix: As most of us know, our tools infrastructure leaves a lot to be desired.
<beach>
fe[nl]ix: That does look like real documentation.
<fe[nl]ix>
not sure it's good, but I'm not an expert
ljavorsk_ has joined #lisp
<beach>
Yeah, me neither. When I emulated the Common Lisp HyperSpec look for the MOP, I got a lot of crap for it.
<fe[nl]ix>
and the main problem is that the sources are barely structured
<fe[nl]ix>
it's really just a little markup
<phoe>
beach: is there any public documentation for Concordia?
<beach>
Not that I am aware of.
<fe[nl]ix>
in a way it's funny that Texinfo can do all that, but the output is atrociously bad
<beach>
Maybe in the Chinual.
<Duuqnd>
Well, there's the documentation that comes with Concordia, but that's all I know of.
<fe[nl]ix>
it's stuck in the '80s
<fe[nl]ix>
is that anywhere online ?
<fe[nl]ix>
for us to take a look
<Duuqnd>
Concordia's documentation is online readable on a Lisp machine as far as I know
<Duuqnd>
s/online/only
<fe[nl]ix>
I see
<fe[nl]ix>
:D
<Duuqnd>
I think Document Examiner had a printing function though so you could probably print it with a virtual printer and get a PDF
<beach>
As I have often said, any markup language is bound to fail to get consensus, simply because there are so many of them that each one is supported by only a small minority of developers.
<beach>
That is why I want to see a documentation system based on CLOS protocols that determine what operations are possible, something that all markup systems seem to fail to provide.
<beach>
Then, different parsers can be provided for different markup languages.
<fe[nl]ix>
a markup system is barely useful so everybody will want their own
<beach>
Yeah, that's part of the problem.
luna_is_here has quit [Ping timeout: 256 seconds]
<Duuqnd>
Concordia 2 when?
<beach>
Sort of like frameworks for testing.
<fe[nl]ix>
if you build a system that gives users the ability to organize in chapters, with cross-refs, indexes, etc...
<beach>
Duuqnd: jackdaniel has been working on "London", but I don't know what it is like.
luna_is_here has joined #lisp
<fe[nl]ix>
they will adopt it no matter the markup
<jdz>
beach: I've been intending to look at https://shirakumo.github.io/cl-markless/ one of these days, it seems to be at least halfway in the direction you describe.
<phoe>
that is not what we are looking for, but it's something
<flip214>
phoe: not the number of bytes is important, but to keep the changes minimal so that it's easier to see the real changes. Like whitespace cleanups should be a separate patch.
<beach>
jdz: Yes, I see. Maybe Shinmera and jackdaniel should talk.
Necktwi has joined #lisp
<beach>
Oh, wow, "Markless", yet another markup language. I wonder how many are created per time unit?
<beach>
I bet the selling point is that you can then generate output in the form of markup for pretty much all previously existing markup languages.
<jdz>
beach: 1.5 times the rate of testing frameworks.
<beach>
Sounds right.
<beach>
... and also HTML, PDF, PostScript, Word,...
<phoe>
well, as long as we write documentation in text editors instead of graphical ones we will be forced to reinvent Markdown, poorly
<flip214>
well, pandoc already can convert quite a set of markups into one another - and into word, LaTeX (and therefore PDF), HTML, DocBook, ...
<phoe>
and by a text editor is something that merely edits text files instead of understanding them - which in turn is required for xrefs and such
<pve>
perhaps related: org-mode with org-babel can be set up to produce nice looking pdfs (through LaTeX) with syntax highlighted lisp code snippets
<flip214>
phoe: well, then just use Lyx ;)
<beach>
phoe: Yes, well, one possibility for a documentation system based on CLOS protocols would be to provide a specialized editor for it.
<phoe>
beach: I consider it a necessity rather than a possibility
<beach>
I do too, but I wanted to tread carefully.
space_otter has quit [Ping timeout: 240 seconds]
<phoe>
oops
<phoe>
well, I guess I'm still too young for careful treading
<beach>
Nah, don't worry about it. :)
<beach>
I just didn't want to scare people.
<beach>
Anyway, when I see this kind of proliferation of markup languages and testing frameworks, I immediately think there is something fundamentally wrong with the very concept.
<phoe>
the current state of documentation in the CL ecosystem is what is the real scary thing
<fe[nl]ix>
Lispers have very high expectations :)
<beach>
I think the only way out is to design some CLOS-based protocols.
<fe[nl]ix>
it's not that much worse than other language environments
<beach>
Then, people can work independently on parsers, PDF generators, editors, whatever.
<phoe>
fe[nl]ix: I guess that I personally do have high expectations after playing a bit with OpenGenera
<beach>
I should look into the state of "London" and maybe give jackdaniel some remarks on it.
<Duuqnd>
I mean, I *could* grab the time machine and stop Symbolics from going under, which would solve the problem...
jibanes has quit [Ping timeout: 256 seconds]
jibanes has joined #lisp
cosimone has joined #lisp
jeosol has joined #lisp
<flip214>
beach: Documentation _has_ some connections to the software (function names, argument names and types, return types, classes, ...) but the missing part is prose. I'm not sure that a CLOS protocol is the right way to go.
<phoe>
flip214: a lot of prose is already out there
<aeth>
Duuqnd: or a money machine, which is hard, but easier than a time machine
<phoe>
look at all the documentation written that uses all sorts of its own markup languages with manual or no xrefs and/or outdated examples that don't compile and such
<flip214>
I'd imagine letting the user choose his markup and use eg. pandoc to convert to something that can be merged with the details from the image.
<phoe>
(including dpANS)
<fe[nl]ix>
flip214: I think I agree
space_otter has joined #lisp
<fe[nl]ix>
the hard part is that you need to feed the system some metadata
<beach>
flip214: Maybe it is not clear what I mean. I mean definitions of classes such as paragraphs, words, titles, cross references, and functions such as formatting, etc.
<beach>
flip214: What would be wrong with such a thing in your opinion?
<fe[nl]ix>
semantic data, like what to include in an index, what / where to x-ref, then there's the prose
<flip214>
pandoc already has an internal JSON format defined, that might be a good first guess https://pandoc.org/filters.html
countvajhula has joined #lisp
<flip214>
beach: ah, you mean the representation of prose as CLOS instances?
<beach>
Yes, of prose, and all the other elements of documentation.
<phoe>
that's a thing that CCLDoc and AsTeR have already reinvented to some degree
<flip214>
I thought you meant (defmethod documentation ((type (eql :class)) (name (eql 'myclass)) (...)))
<beach>
Not at all.
Bourne has joined #lisp
<phoe>
that's just docstrings though
<phoe>
CL:DOCUMENTATION is very limited in this regard
<beach>
phoe: Do they document the protocols? I thought CCLDoc was only s-expressions.
<phoe>
beach: CCLDoc does not document its protocols; it has an internal structure for documents/paragraphs and such and a way of reading these from sexp files.
<flip214>
fe[nl]ix: well, I had good results with doxygen, so why not define ";;*" as the starting tag of a parsable-comment block? (variable number of semicolons, of course)
<beach>
So again, we are talking I/O, which is precisely what I want to avoid.
<flip214>
beach: well, I/O is _exactly_ what the users (the people writing documentation) mostly care about!
<beach>
flip214: And that is no doubt why everybody gets the abstractions wrong.
<flip214>
important points: * easy * quick * known markup format
<phoe>
flip214: that's why we have lots of the I/O and little of the overall cohesion that we want
<beach>
phoe: Exactly!
<fe[nl]ix>
flip214: I don't want to embed documentation in my source files, that's precisely what I want to avoid
<flip214>
also because of the lisp curse
<beach>
fe[nl]ix: Good for you!
<flip214>
fe[nl]ix: well, doxygen also allows to use separate files, we can copy that as well
countvajhula has quit [Ping timeout: 260 seconds]
<fe[nl]ix>
beach: I'm not sure if that was ironic or not
<flip214>
I'm using that as well... but being able to explain some configuration convention right at the point where it's implemented is very nice
<beach>
Not at all.
<fe[nl]ix>
hahaha
<beach>
fe[nl]ix: Not at all. I totally agree with you.
ark has joined #lisp
toorevitimirp has joined #lisp
* beach
thinks that his point of view is not getting across very well.
<fe[nl]ix>
ok
<fe[nl]ix>
pandoc is also inadequate because it's just an engine for transforming between markup formats
countvajhula has joined #lisp
<beach>
If we put documentation in source files, we need to either use plain text, which is inadequate, or we need to agree on a markup language, which, as I said, we can't.
<phoe>
flip214: ideally you'd be able to right-click that symbol and choose an option to view its documentation
<fe[nl]ix>
it doesn't make it easy to process the info for producing a manual
<phoe>
and that documentation wouldn't be a plain text file
<phoe>
and all of this is infrastructure that we don't have at the moment.
<beach>
phoe: We are in total agreement here.
<phoe>
and all of this infrastructure is absolutely required to avoid the curse of documentation written in plain text and/or yet another markdown derivative
<fe[nl]ix>
unless somebody takes initiative, I hope to write some sort of design doc in the next few months
<fe[nl]ix>
maybe if I take a vacation :D
<phoe>
:D
<beach>
Since we probably need to save documentation to files (given the state of current operating systems), we could use some very simple format like what I use for ASTs in Cleavir: [<class-name> :initarg1 <value1> :initarg2 <value2>...].
<beach>
fe[nl]ix: Good plan. Maybe check what jackdaniel did too.
<flip214>
phoe: beach: well, I think we don't need to agree on a markup format. Define a comment tagging mechanism and pass via an argument which format is in use, then use pandoc to convert to whatever representation your UI wants.
<flip214>
defining a new markup type is surely the wrong way to go...
countvajhula has quit [Ping timeout: 244 seconds]
<beach>
Nobody is suggesting that.
<flip214>
and even my non-lispy vim can fold comment sections away, so if it's in the source files it doesn't _have_ to get in the way.
<fe[nl]ix>
I'll take a note of cl-markless. it does have good ideas
<beach>
*sigh*
<beach>
I think I'll be quiet now.
<fe[nl]ix>
what was jackdaniel's work named ?
<phoe>
London
<beach>
London.
TDAM has quit [Remote host closed the connection]
<beach>
But I haven't had time to look at it at all, so I don't know whether he is on the right track.
<fe[nl]ix>
does anyone have a link ?
<beach>
I just suspect he is, because he has heard all the arguments.
<beach>
jackdaniel: Do you have a link to "London"?
<fe[nl]ix>
"jackdaniel london" is an unlucky combination to search online
<fe[nl]ix>
right, he's here
nirved has quit [Ping timeout: 240 seconds]
ramus has quit [Ping timeout: 256 seconds]
ramus has joined #lisp
cmatei has quit [Ping timeout: 265 seconds]
jibanes has quit [Ping timeout: 256 seconds]
jibanes has joined #lisp
cmatei has joined #lisp
tourjin has joined #lisp
treflip has quit [Quit: WeeChat 2.6]
ajithmk has joined #lisp
nicktick has quit [Ping timeout: 240 seconds]
treflip has joined #lisp
nicktick has joined #lisp
sympt_ has joined #lisp
<jackdaniel>
the name is indeed inspired by Jack London, who was a writer
<jackdaniel>
no, the protytype is not online, it is not useful yet
gravicappa has joined #lisp
sympt has quit [Ping timeout: 246 seconds]
space_otter has quit [Ping timeout: 246 seconds]
<jackdaniel>
(and I didn't work on it lately)
<jackdaniel>
hm, maybe I'll rewrite the clostrum documentation in it to see some rough edges
toorevitimirp has quit [Quit: Konversation terminated!]
<jackdaniel>
contrapunctus: the point is to have a "live" documentation in a program (in contrast to a source code), with ability to save/restore that documentation
<jackdaniel>
then you can add import/export functionalities, or even live markup parsers when writing the documentation
<phoe>
contrapunctus: oh look, another markup format
<contrapunctus>
phoe: Scriba is what CommonDoc uses 🤨
<phoe>
yes, I see the distinction now
<phoe>
commondoc looks like the set of protocols beach was talking about
<phoe>
and scriba parses to this sort of structure
<contrapunctus>
Where's Eudoxia these days? 🤔
dra has quit [Quit: Leaving]
<contrapunctus>
Well lol "This library can be considered an implementation of Robert Strandh's suggestion for the creation of a library for representing documents [...]"
<phoe>
wait what
tourjin has quit [Ping timeout: 246 seconds]
<phoe>
hahahaha
orivej has joined #lisp
orivej has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
v88m has quit [Ping timeout: 260 seconds]
markong has joined #lisp
countvajhula has joined #lisp
<contrapunctus>
Oh, great. I'm gonna try using this for TheatreScript.
<splittist>
Documents are not trees.
<phoe>
splittist: you mean because of xrefs?
<splittist>
At least, they're not simple trees.
countvajhula has quit [Ping timeout: 260 seconds]
<phoe>
what exactly do you mean?
<splittist>
This is a good question. (:
<phoe>
oh
<phoe>
okay
<splittist>
I think most document modelling goes too quickly from the abstract (tree) to the particular (italics, numbered list). There are useful layers that could fit in between.
markong has quit [Ping timeout: 240 seconds]
markoong has joined #lisp
<splittist>
Is a paragraph a semantic unit, or a layout one, for example.
heredoc has joined #lisp
orivej has quit [Ping timeout: 256 seconds]
orivej has joined #lisp
shifty has quit [Ping timeout: 240 seconds]
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
<Bike>
i see, it doesn't even try to expose all of atomics, it just defines a holder class
<Bike>
that's pretty reasonable in light of how patchy things are across implementations per shinmera's tracker
abhixec has quit [Ping timeout: 256 seconds]
<fe[nl]ix>
Bike: I'm preparing a blog about it
<fe[nl]ix>
but you got the gist of it
<fe[nl]ix>
support is so uneven that I can only export something higher-level
<fe[nl]ix>
an atomic counter, maybe a simple queue
<fe[nl]ix>
can't do much in the current state
<Bike>
yeah. i've thought some about what an actual standard would look like and it would at least require a fair bit of work on every implementation
<Bike>
specially if you want to expose sub-sequential-consistency foot shooting mechanisms
<fe[nl]ix>
not necessarily, they all seem to have the compiler plumbing for it
<Bike>
i didn't see any implementation making guarantees of consistency for non-cas accesses
<fe[nl]ix>
for example, some implementations support atomic ops for struct accessors, but only for boxed slots
<fe[nl]ix>
some only for typed slots
<Bike>
and one of the few libraries i could find using atomics, lparallel, assumes reads are sequentially consistent, i believe
<Bike>
sbcl has some stuff with barriers but it doesn't look very friendly
<fe[nl]ix>
the only implementation that has a documented and well-thought API for barriers seems to be Lispworks
Josh_2 has quit [Remote host closed the connection]
<fe[nl]ix>
the level of quality if Lispworks is impressive
<jackdaniel>
fwiw ecl has barriers too (re sequential ordering)
<fe[nl]ix>
is that documented ?
<jackdaniel>
it is weird, but they are not
<jackdaniel>
I had to forgot about them when writing that part
whiteline has quit [Remote host closed the connection]
whiteline has joined #lisp
<jackdaniel>
ah, barrier and mailbox documentation are commented out in the mp.txi
bitmapper has joined #lisp
<jackdaniel>
maybe I did not finish that then
<jackdaniel>
yes, only names and index entries are there
<aeth>
jackdaniel: document it so we can say "the level of quality of ECL is impressive"!
<jackdaniel>
native threads on ecl are, well, not impressive
<jackdaniel>
they are certainly useful though and a lot of effort was put to make them work
ebrasca has quit [Remote host closed the connection]
zigpaw has quit [Ping timeout: 240 seconds]
<fe[nl]ix>
in what sense are they not impressive ?
gaqwas has joined #lisp
gaqwas has joined #lisp
<jackdaniel>
timeouts are not implemented (I have them working locally, but that needs cleanup I did not have time to apply lately). also, they are based on spinlocks for portability; I suppose using i.e pthreads unices would be better for both cpu and performance
<jackdaniel>
I want to also bring back green threads, so there is n-to-m mapping; but that's another story
gaqwas has quit [Remote host closed the connection]
whiteline has quit [Ping timeout: 246 seconds]
v0|d has joined #lisp
zigpaw has joined #lisp
<fe[nl]ix>
jackdaniel: once Linux gets support for usermode scheduling, I'd like to experiment with a simpler Lisp before adding that support to SBCL
<p_l>
fe[nl]ix: doesn't read to me as full MxN threading... more like another implementation of what was part of QNX RPC port or the code that is part of Android Binder
<p_l>
(where RPC call to another thread transferred your schedule slot as well
jw4 has quit [Read error: Connection reset by peer]
bsd4me has joined #lisp
<jackdaniel>
fe[nl]ix: if you have questions regarding ecl (if you decide to experiment with it) please let me know
<jackdaniel>
btw, since I have your attention, bump r.e for-all* macro in fiveam PR
* jackdaniel
is going afk
bitmapper has quit [Ping timeout: 256 seconds]
jw4 has joined #lisp
Oladon has joined #lisp
nostoi has joined #lisp
nostoi has quit [Client Quit]
<fe[nl]ix>
p_l: no, that's kernel support for userland scheduling
kaftejiman has joined #lisp
<fe[nl]ix>
it's technically still 1:1 but the process can determine its scheduling priorities and control switching
<fe[nl]ix>
so in that sense it's similar to Binder
<fe[nl]ix>
the bonus is that all your code still works: mutexes, I/O etc...
ayuce has quit [Read error: Connection reset by peer]
ayuce has joined #lisp
Josh_2 has joined #lisp
<p_l>
Binder did that combined with the RPC - this meant that when you call a "remote" service, you stay in the same scheduler time slice
treflip has quit [Quit: WeeChat 2.6]
ajithmk has quit [Quit: Connection closed for inactivity]
countvajhula has joined #lisp
ayuce has quit [Remote host closed the connection]
MichaelRaskin has joined #lisp
gaqwas has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
ahungry has joined #lisp
contrapunctus has joined #lisp
kaftejiman has quit [Remote host closed the connection]
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
rumbler31_ has quit [Ping timeout: 256 seconds]
contrapunctus has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
gaqwas has quit [Ping timeout: 260 seconds]
<gendl>
Hi, does usocket support ipv6 sockets?
<Duuqnd>
It does when using SBCL or CCL
gaqwas has joined #lisp
gaqwas has joined #lisp
gaqwas has quit [Changing host]
<Duuqnd>
From usocket's page on common-lisp.net: "(IPv6 support is also in progress and already available for SBCL/CCL with version 0.6.3+)"
<gendl>
ok good - that's all I need for right now
rumbler31_ has joined #lisp
<gendl>
now i have to make sure i have that version and see how to use it. I'm not seeing an argument for ip version in usocket:socket-listen
<gendl>
Looks like usocket's IPv6 is done for LispWorks as well.
<gendl>
aaaand that documentation is from 2010 apparently.
EvW1 has joined #lisp
whiteline has joined #lisp
<Duuqnd>
It'll still work, usocket hasn't ever changed much
rumbler31_ has quit [Ping timeout: 240 seconds]
theseb has joined #lisp
<gendl>
I think I see my answer at the top of usocket.lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
<gendl>
if you simply specify an ipv6 host to socket-listen, it'll be a ipv6 socket. Or just use *wildcard-host* which will make it listen for ipv6 connections on ipv6 capable systems.
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
hendursaga has quit [Read error: Connection reset by peer]
hendursaga has joined #lisp
bitmapper has joined #lisp
<phoe>
yes
<phoe>
I remember being stung by usocket that making a socket on "localhost" opened a socket on ::1
<dlowe>
hah. That would be super annoying to debug.
<phoe>
thankfully I had unit tests for that
<phoe>
I explicitly connected to "127.0.0.1" on the client
vutral has joined #lisp
<phoe>
but imagine if I connected to "localhost" instead...
mankaev has quit []
mankaev has joined #lisp
kaftejiman has joined #lisp
wsinatra has quit [Quit: WeeChat 2.9]
ayuce has joined #lisp
gaqwas has quit [Remote host closed the connection]
MightyJoe has quit [Ping timeout: 256 seconds]
cyraxjoe has joined #lisp
lnostdal has quit [Quit: "Fascism, Nazism, Communism and Socialism are only superficial variations of the same monstrous theme—collectivism." -- Ayn Rand]
narimiran has joined #lisp
<MichaelRaskin>
Wait, on ::1, not :: ?
<MichaelRaskin>
Ah right, ::1 for localhost. I wonder when it will listen both protocols on loopback. like :: includes listening on 0.0.0.0 in some cases…
orivej has joined #lisp
gaqwas has joined #lisp
gaqwas has quit [Changing host]
gaqwas has joined #lisp
hvxgr has quit [Quit: leaving]
karlosz has joined #lisp
karlosz has quit [Remote host closed the connection]
greaser|q has quit [Changing host]
greaser|q has joined #lisp
greaser|q is now known as GreaseMonkey
shifty has quit [Ping timeout: 256 seconds]
<p_l>
usocket is too close to BSD sockets :(
hvxgr has joined #lisp
ggole has quit [Quit: Leaving]
akoana has joined #lisp
jcowan has joined #lisp
dra_ has joined #lisp
<jcowan>
What are use cases for conditions that are neither errors nor warnings? (I know that storage-condition is neither.)
<p_l>
jcowan: non-local control flow
<p_l>
jcowan: for example, providing a way to select actions deep in your code in clean way
<p_l>
also, the classic example is about interactive REPL, I believe, where technically there's an error
<jcowan>
That sounds more like restarts than conditions. What I am asking is about application condition types that descend neither from `error` nor from `warning`.
dra_ is now known as dra
xkapastel has joined #lisp
tristero has quit [Ping timeout: 265 seconds]
xrash has quit [Ping timeout: 256 seconds]
countvajhula has quit [Ping timeout: 244 seconds]
countvajhula has joined #lisp
mankaev has quit [Read error: Connection reset by peer]
<lonjil>
jcowan: all condition handlers can do non-local control flow, and in any case you'd would signal a condition for someone to be able to select a restart even if there's no error or anything to warn about.
<jcowan>
Sure. But what are concrete examples of "exceptional situations"?
mankaev has joined #lisp
countvajhula has quit [Ping timeout: 244 seconds]
gaqwas has quit [Remote host closed the connection]
<jcowan>
I guess resource exhaustion (anything, not just memory) makes sense as a use case.
uplime is now known as [
edgar-rft has joined #lisp
<pve>
jcowan: I'm writing a small language where the reader/parser may encounter expressions similar to (eval-when ...). When it does, it signals a condition that contains the expression, so that whoever invoked the parser may choose how to handle it (execute or ignore).
<jcowan>
Makes sense
<pve>
not sure if it's good design, but it works for now
kaftejiman has quit [Remote host closed the connection]
<pve>
this condition is neither error nor warning
gaqwas has joined #lisp
gaqwas has quit [Changing host]
gaqwas has joined #lisp
<pve>
that's my biggest difficulty with conditions, they always make me go "hmm, is this good design or just spaghetti?"
narimiran has quit [Ping timeout: 260 seconds]
markong has joined #lisp
Oladon has quit [Quit: Leaving.]
TwoNotes has left #lisp ["Leaving"]
markoong has quit [Ping timeout: 246 seconds]
astronavt has quit [Disconnected by services]
<aeth>
pve: and the answer is always yes
astronavt___ has joined #lisp
<phoe>
pve: you might want to use the idiom of (with-simple-restart (muffle-my-condition "Muffle my condition.) (signal 'my-condition))
<phoe>
this additionally lets the handler in question prevent next handlers from running, if - for whatever reason - it considers that to be appropriate.
<aeth>
pve: I'd personally make it optional and put it under a keyword argument (or something similar... maybe just a global dynamic variable) so the behavior of ignoring all conditions is implemented as a simple boolean lookup rather than signalling and then ignoring conditions.
<aeth>
Afaik this behavior needs to exist for e.g. --non-interactive in sbcl (or flags that imply that, or other CLs that use other command line flags)
<pve>
phoe: yeah I could do that
orivej has quit [Remote host closed the connection]
<pve>
aeth: could do that too
orivej has joined #lisp
dominic34 has joined #lisp
<pve>
aeth: do you mean that --non-interactive bails on unhandled conditions of type "condition"?
<aeth>
pve: --non-interactive will, which is fine, because when you're using a Lisp non-interactively like that, the two most simple cases in your case would be (1) exit program with an error (basically for "free") or (2) ignore all of your custom conditions
<aeth>
#2 is equally trivial, but if done (no matter where in the program) by signalling and ignoring a condition, it'll be like... 1000x slower than a WHEN around each SIGNAL. If not more.
<aeth>
So if ignoring all is an expected common path, then I think it makes sense to extremely optimize for it in the API by putting a WHEN around each SIGNAL. (You don't need to optimize the exit-with-an-error path, since that doesn't have to be efficient)
<aeth>
phoe's path is not quite the same thing, in case you missed the distinction. That's the case where you handle it (at least) once and after a certain point ignore all of the rest. Although you might be able to modify the variable tested in WHEN there, too.
<pve>
no I got it
torbo has joined #lisp
<pve>
but I just tried sbcl --non-interactive --load foo.lisp where foo.lisp signals a "condition", and sbcl didn't error out
<pve>
was that what you meant?
<aeth>
oooh, interesting
<aeth>
Is the condition unhandled?
<fwoaroof[m]>
sbcl almost never exits non-zero
<fwoaroof[m]>
unless you call some implementation-specific method to set the exit code
<pve>
yeah, and signalled with (signal 'mycondition)
<fwoaroof[m]>
it's always been a bit annoying, because it's a pain to deal with in CI
<pve>
by error out, I meant didn't show the usual backtrace
orivej has quit [Remote host closed the connection]
<pve>
so I assume the condition was just not handled and everything was fine
<fwoaroof[m]>
although, maybe that's changed?
<aeth>
fwoaroof[m]: It exists with error code 1 in --non-interactive if it gets an error at compile time. It doesn't always do that with an error?