krkini has quit [Remote host closed the connection]
kini has joined #lisp
dbotton has quit [Quit: This computer has gone to sleep]
<beach>
Good morning everyone!
Alfr has joined #lisp
Alfr_ has quit [Ping timeout: 260 seconds]
anticrisis has quit [Read error: Connection reset by peer]
stoneglass has quit [Quit: stoneglass]
orivej has quit [Ping timeout: 256 seconds]
madage has joined #lisp
bacterio has quit [Ping timeout: 240 seconds]
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
nydel has quit [Ping timeout: 260 seconds]
judson_ has joined #lisp
thinkpad has quit [Ping timeout: 264 seconds]
thinkpad has joined #lisp
Oladon has quit [Quit: Leaving.]
edgar-rft has quit [Quit: Leaving]
nydel has joined #lisp
Oladon has joined #lisp
mrcom has joined #lisp
bacterio has joined #lisp
nicktick has quit [Ping timeout: 256 seconds]
nicktick has joined #lisp
bacterio has quit [Ping timeout: 240 seconds]
nydel has quit [Ping timeout: 240 seconds]
Oladon has quit [Read error: Connection reset by peer]
Oladon has joined #lisp
saganman has joined #lisp
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
nydel has joined #lisp
totoro2021 has joined #lisp
<splittist>
good morning beach
bacterio has joined #lisp
erronius has quit [Ping timeout: 260 seconds]
erronius has joined #lisp
anticrisis has joined #lisp
andreyorst has joined #lisp
Nilby has joined #lisp
judson_ has joined #lisp
thinkpad has quit [Ping timeout: 246 seconds]
clintm has joined #lisp
thinkpad has joined #lisp
karlosz has quit [Quit: karlosz]
asarch has joined #lisp
shynoob has joined #lisp
kini has quit [Remote host closed the connection]
kini has joined #lisp
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
sauvin has joined #lisp
pillton has quit [Quit: ERC (IRC client for Emacs 27.1)]
nicktick has quit [Ping timeout: 272 seconds]
nicktick has joined #lisp
thinkpad has quit [Ping timeout: 264 seconds]
thinkpad has joined #lisp
shynoob has quit [Remote host closed the connection]
shynoob has joined #lisp
judson_ has joined #lisp
asarch has quit [Quit: Leaving]
narimiran has joined #lisp
v88m has quit [Ping timeout: 246 seconds]
PuercoPop has quit [Quit: WeeChat 2.8]
Nilby has quit [Read error: Connection reset by peer]
gzj has joined #lisp
aeth has quit [Ping timeout: 260 seconds]
andreyorst` has joined #lisp
andreyorst` has quit [Remote host closed the connection]
andreyorst` has joined #lisp
aeth has joined #lisp
orivej has joined #lisp
Cymew has joined #lisp
zugzwang_ has joined #lisp
andreyorst has quit [Ping timeout: 264 seconds]
gzj has quit [Remote host closed the connection]
gzj has joined #lisp
midre has quit [Ping timeout: 264 seconds]
shynoob has quit [Ping timeout: 264 seconds]
Blukunfando has quit [Ping timeout: 264 seconds]
shka_ has joined #lisp
Blukunfando has joined #lisp
gzj has quit [Remote host closed the connection]
gzj has joined #lisp
orivej has quit [Ping timeout: 264 seconds]
orivej has joined #lisp
jeosol has quit [Ping timeout: 248 seconds]
aartaka has joined #lisp
midre has joined #lisp
rumbler31 has quit [Read error: Connection reset by peer]
ech has quit [Remote host closed the connection]
rumbler31 has joined #lisp
ech has joined #lisp
bacterio has quit [Ping timeout: 246 seconds]
zugzwang_ has left #lisp ["Leaving"]
bacterio has joined #lisp
gzj has quit [Read error: Connection reset by peer]
gzj has joined #lisp
ome has quit [Quit: Connection closed for inactivity]
<fiddlerwoaroof>
Xach/aeth: yeah, my goal would be to include things like Alexandria that should reasonably be expected to be usable anywhere
rumbler31_ has quit [Ping timeout: 240 seconds]
<fiddlerwoaroof>
quicklisp or ultralisp would be used for things like clim that require functionality beyond the standard
<aeth>
well, more clim backends (that don't currently exist?) than clim, since clim itself would be fine
<fiddlerwoaroof>
I guess so
gzj has quit [Remote host closed the connection]
gzj has joined #lisp
jeosol has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
frodef has quit [Ping timeout: 240 seconds]
gzj has quit [Remote host closed the connection]
gzj has joined #lisp
gaqwas has joined #lisp
gaqwas has quit [Changing host]
gaqwas has joined #lisp
lottaquestions_ has quit [Remote host closed the connection]
lottaquestions_ has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
marusich has quit [Read error: Connection reset by peer]
xificurC has joined #lisp
frodef has joined #lisp
rumbler31_ has joined #lisp
mrcom has quit [Ping timeout: 265 seconds]
jello_pudding has quit [Ping timeout: 268 seconds]
rgherdt has joined #lisp
liberliver has joined #lisp
mrcom has joined #lisp
thinkpad has quit [Ping timeout: 240 seconds]
thinkpad has joined #lisp
varjagg is now known as varjag
heisig has joined #lisp
wxie has joined #lisp
attila_lendvai has joined #lisp
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
madage has quit [Ping timeout: 240 seconds]
frodef has quit [Ping timeout: 258 seconds]
skapata has quit [Ping timeout: 246 seconds]
madage has joined #lisp
skapata has joined #lisp
[d] has quit [Ping timeout: 264 seconds]
imode has quit [Quit: Actual honest-to-goodness real sleep I swear to god for real this time.]
ljavorsk has joined #lisp
dmc00 has quit [Remote host closed the connection]
pve has joined #lisp
SpaceIgor2075 has joined #lisp
SpaceIgor2075 has quit [Remote host closed the connection]
nicktick has quit [Ping timeout: 264 seconds]
nopf has joined #lisp
anticrisis has quit [Read error: Connection reset by peer]
gaqwas has quit [Remote host closed the connection]
andreyorst has joined #lisp
ludston has joined #lisp
<ludston>
Is there a quick and dirty way in CLOS to wrap a struct with another struct that proxies through all of the accessors on the wrapped struct?
<jeosol>
beach: I am reading your paper. The template is used is the suggested one for ELS. Do you have a link for the template handy. I think I have seen slightly different designs.
andreyorst has quit [Ping timeout: 264 seconds]
voidlily has quit [Ping timeout: 264 seconds]
<beach>
jeosol: I guess it must be on the ELS website.
SpaceIgor2075 has joined #lisp
<beach>
Or, rather, the link to it.
<jeosol>
beach: thanks, I get it from there then.
<beach>
jeosol: I just copy my old papers and modify them. It is entirely possible that my template is out of date.
<jeosol>
I am taken by the comment in the abstract that presence of optional and/or keyword argument impacts function call performance
<jeosol>
oh ok. I recally having seen a different format. No worries, I'd pick one from the site and create a base template folder
<beach>
"taken by" in what way?
<beach>
Or you can pick up one of my papers. :) It is in SICL/Papers/...
<beach>
It's on the ELS site.
<beach>
Under "Submissions"
makomo has joined #lisp
<jeosol>
by "taken by", I mean understand how bad design may reduce performance, and certain styles are better. I'd have to read everything to get the full gist
<jeosol>
for the paper, I was referring the the tex sources
<beach>
I don't know how much you know about the design of a typical Common Lisp system, but keyword parameter must typically be parsed by the callee for each call. The rules are complicated. For example, the same keyword argument may occur more than once, and it's the first one that counts.
<beach>
And if :ALLOW-OTHER-KEYS <true> occurs somewhere in the argument list, then no error should be signaled for unrecognized keyword/argument pairs.
<jeosol>
No, I am not a compiler guy, at all, I am mostly application focused, i.e., using the language. I have only started getting deep in the internals as I try to improve performance and get better design
<jeosol>
so the paper will help in that regard
<beach>
I see.
<beach>
Well, as the paper says, compiler macros are often used to avoid this parsing in many cases.
<jeosol>
yes, with the multiple keyword, the first one is the one that counts/is taken
voidlily has joined #lisp
<jeosol>
I remember that
<beach>
So the callee must loop over all the arguments in order.
<jeosol>
yes, and also the :allow-other-keys
<beach>
So the arguments must probably be saved in order on the stack.
<beach>
... the keyword arguments at least.
<jeosol>
I have used that to cheat when I pass in a large set of keywords to make-instance
<beach>
Whereas for ordinary arguments, registers can be used.
<beach>
Right.
<jeosol>
I think it's interesting to understand how one can lose performance
<jeosol>
find details that needs to be understand
<beach>
Keyword arguments are very flexible, but if you do it naively, then they are very slow.
<beach>
But the technique in the paper basically creates an automatic compiler macro for each call site.
<jeosol>
That's the part I need to probably improve. I have an object with many slots and in my first iteration, I had a constructor with more keywords that slots as I have to pass other arguments, process then, create objects that are then passed into make-instance. I could probably make things better
<beach>
I see.
mankaev has quit []
mankaev has joined #lisp
<ludston>
jeosol: If you're gunning for efficient code, your constraint is more likely to be the garbage collector than function/method dispatch speed in my experience
<beach>
Also, in the naive case, the callee must check whether a certain argument was supplied at all, and if not, execute the initform for the corresponding parameter. That's another test which are expensive these days. With my technique, that test can often be skipped, because it is often clear from the call site whether it is given or not. Barring APPLY of course.
<jeosol>
ludston: thanks for that
seok has joined #lisp
<seok>
hey guys!
<beach>
jeosol: I don't recall you being worried about generic dispatch though.
<jeosol>
I have a case for an optimization that is doing table-look for the function calls, and I have feel it could be faster.
<beach>
Hello seok.
<seok>
Hi beach!
frodef has joined #lisp
<jeosol>
beach: I think the generic dispatch are okay. The most I have is dispatch on two classes (multiple dispatch cases).
ralt has joined #lisp
<jeosol>
I would have to do a benchmarking at least for the table lookup case and see
<ludston>
jeosol: I recommend you don't worry about how fast it is until it's going to be (or is) a problem, and then use statistical profiling techniques to make sure you know exactly what the bottleneck is
<jeosol>
that's what I meant - latter part of your comment
<beach>
PCL generic dispatch is not that great, which is why some SBCL users avoid generic functions. I think that's a pity, because it's an implementation detail that may change.
<jeosol>
I am not too worried per se, because the practical application, calls to another application is the main bottle neck and can't be optimized
iskander has joined #lisp
iskander- has quit [Ping timeout: 256 seconds]
<frodef>
beach: on the other hand, an abstraction that is avoided because of its implementation, has a problem one way or the other.
<jeosol>
beach: really beach. My application is CLOS heavy. It runs well though, but I haven't compared to anything else. It was just easier to build the class hierarchies that way
<beach>
frodef: In this case, the only problem seems to be that implementations were conceived at a time when memory was as fast as register operations.
<jeosol>
it will be nice (perhaps in the future) to get some documentation of these type of design considerations and why some are better than others, e.g., like examples when adding to list
<frodef>
beach: that sounds to me like a (potentially) serious problem...
<beach>
frodef: I am not sure what you mean? Problem with the abstraction?
<beach>
jeosol: I think you are going to need SICL, once we have implemented all those techniques we came up with. :)
<frodef>
beach: yes, if the abstraction can only be implemented in ways that are (prohibitively) expensive.
<beach>
frodef: But I just told you that there are better ways. And they are documented.
<frodef>
beach: sorry, I didn't get that. (I just logged on, might have missed it.)
<beach>
frodef: In this case, the ONLY problem seems to be that IMPLEMENTATIONS were conceived at a time when memory was as fast as register operations.
<jeosol>
beach: that will be nice, and I'd have a clear benchmark - my application is heavy with number crunching and it seems these additions will/should show differences with base SBCL
<beach>
frodef: Which is why I implemented the technique that most people now call "fastgf".
<ludston>
frodef: I agree with beach, long-term it is not a problem that generic dispatch is inefficient in current implementations, and short-term, it is only a problem if you are CPU-constrained... Which you almost never are these days
<frodef>
beach: ok, I misunderstood.
<beach>
frodef: Did you see the paper I wrote about it?
<beach>
scymtym has an adaptation of it for SBCL, but it seems it will never make it to the SBCL code base.
<frodef>
beach: no, I was just going to ask. thanks for the link. Is that "fastgf"?
<frodef>
why not into SBCL?
<beach>
It's what the cool kids (Bike, drmeister, karlosz, etc.) call my technique from that paper.
[d] has joined #lisp
<beach>
frodef: I don't know the details, and scymtym was a bit vague about it. But the technique depends somewhat on how SICL represents standard objects, so a fair amount of restructuring of SBCL would be needed to take full advantage of it.
<frodef>
right
<beach>
frodef: Boy, you have a lot to catch up with, having been away for so long. :)
<frodef>
:)
liberliver has quit [Quit: liberliver]
<frodef>
in general, imho the "almost nothing is CPU-bound" attitude is fine for applications, not so much for the language/runtime.
<ludston>
If you inline dispatch, then add a new method implementation that is more specific to somewhere already inlined, you have to go back everywhere you inlined it and change it?
<beach>
Correct. Which is why generic functions are typically not inlined.
iskander has quit [Ping timeout: 240 seconds]
<beach>
ludston: But with the technique in my (draft) paper, that is no problem.
mankaev has quit [Ping timeout: 246 seconds]
iskander has joined #lisp
mrios22 has joined #lisp
<ludston>
beach: I'm guessing the sbcl 'call history' isn't up to scratch
<beach>
The call history is still shared by all callers, so that won't be enough.
<beach>
ludston: There is a similar technique (but much less efficient) used by CMUCL and SBCL for MAKE-INSTANCE in particular. The call site is replaced by a call to a new funcallable instance that works only for the particular argument list of that call site. Then when the callee changes, the funcallable instance function is updated accordingly.
<beach>
But that technique involves another function call, so there will still be indirections.
<beach>
And the call protocol must be respected.
<ludston>
beach: But that may or may not be a problem if your cpu's branch prediction is good
<beach>
The call itself may not be a big problem, and saving on generic dispatch will help. But by respecting the call protocol, I mean putting arguments in the agreed-upon places, loading the static environment, creating the callee stack frame, etc. All that adds up.
<frodef>
btw what is the expected cost of a memory access that is a first-level chache hit (e.g. second access to same object) compared to a register access?
<beach>
Let me check...
<ludston>
It's some absurd exponential difference IIRC
<White_Flame>
iirc 2-4 cycles?
<frodef>
ludston: really? I'd expect the difference to be small..
HDurer has quit [Remote host closed the connection]
<frodef>
moon-child: I seem to remember the stack works somewhat like that?
<moon-child>
stack will presumably generally be quite hot, but it's not limited to that; example there shows it indirecting rsi
<ludston>
New CPU's calculate a graph of the instructions that it is running next in order to run them in parallel. A branch misprediction means you have to throw that whole graph out and start again
<ludston>
Maybe not the whole graph.
mankaev has joined #lisp
<moon-child>
yeah
<moon-child>
cpus usually speculate return addresses, with high probability--also looking at stack
<moon-child>
(though shared call and data stack is somewhat harmful for security since it enables rop)
<ludston>
I wonder how sbcl does in that regard? Probably really well given the benchmarks
<frodef>
(btw again it seems to me there's a difference between an application developer saying "branch prediction will fix that" etc, while a run-time must be careful to limit the (undue) pressure on such CPU resources.)
<beach>
frodef: I tend to agree with you.
gaqwas has joined #lisp
<ludston>
frodef: I agree that it is worth optimising the language in any way possible
* beach
is working on it.
housel has quit [Ping timeout: 246 seconds]
<ludston>
beach: Thanks :0
* frodef
can't seem to find the thumbs-up icon on this weird social media platform.
<phoe>
frodef: IRC does not have thumbs ups yet
<beach>
Some people disagree though. For example, stassats doesn't think that requiring two tests instead of one, for each loop over a list, is a problem. And he doesn't think registers are that much faster than the stack.
<frodef>
phoe: ..nor the irony icon ;)
<phoe>
:D
<beach>
But I think those problems are fun to work on, so I will continue doing so.
<ludston>
DAE notice that around Christmas every year, there is a surge of lisp related articles on all the programming news sites?
<frodef>
btw CPUs are becoming quite clever at optimizing... for C-type runtimes. It's fun/sad to think what the state of CPUs might have been if dynamic run-times weren't weeded out in the 80s.
<ludston>
frodef: Dynamic run-times are dominant currently
<frodef>
ludston: yes, but in a rather roundabout way.
<White_Flame>
there's still barely any hardware GC support (and afaik what is in there isn't even used in major languages like Java), and still no support for tagged words
<ludston>
frodef: In a direct, explicitly dynamic way: Javascript, Python and all the byte-code langs like C# and Java
HDurer has joined #lisp
iskander has quit [Ping timeout: 264 seconds]
iskander- has joined #lisp
<frodef>
ludston: I might be outdated, but e.g. python is basically a huge interpreter written in C, no?
<ludston>
frodef: What language the interpreter is written in is not necessarily relevant to the assembler/bytecode it emits. Pypython used to be a python interpreter written in python, but I just searched for it and it doesn't look like it is anymore
surabax has joined #lisp
hnOsmium0001 has quit [Quit: Connection closed for inactivity]
iskander- has quit [Read error: Connection reset by peer]
liberliver has joined #lisp
<frodef>
ludston: is python typically ran as compiled machine code? Point is, iirc the "run-time" is basically a C program/state-machine driven by python text or bytecode.
iskander has joined #lisp
<ludston>
You basically need c to bootstrap for any new CPU architecture these days regardless. i.e. step 1, someone writes a C compiler for the new architecture, step 2, compile common lisp interpreter written in C, step 3: compile sbcl using that interpreter
<frodef>
in other words, if you have a C compiler, you also have a python "run-time".
<beach>
ludston: But that's beside the point, no? Once you are done with that, you never use the C runtime again.
<frodef>
ludston: I don't think the CL compiler for the new CPU will magically appear just because you have a C compiler.
<frodef>
(is SBCL still based on C bootstrapping?)
<ludston>
frodef: Not sure how python works these days to be honest. They may or may not have a byte-code
<ludston>
No, to compile sbcl you need a common lisp runtime
scymtym has joined #lisp
wxie has quit [Ping timeout: 256 seconds]
<frodef>
ludston: but do you need a CL runtime that is running on the (hypothetical) new CPU?
<ludston>
beach: That's my point. You can't argue languages with dynamic runtime are c-based once you don't need c
<ludston>
frodef: Yes, so either you have to write your own CL interpreter for the new CPU archictecture (a massive effort), or, just compile clisp and then use clisp to compile sbcl
<ludston>
At some stage you're going to need to tweak sbcl so that it will compile for the new architecture, but the point is that you only write lisp code
<frodef>
fwiw by "C-based" I meant similar to typical C code. For example C# run-time I suspect is heavily influenced by the performance model of CPUs as of 20 years ago, which again comes basically from C.
aartaka_d has joined #lisp
<ludston>
C# makes me sad
<dim>
well then make it 40/50 years ago maybe, about the CPU and memory model used in the C langauge
<frodef>
or to rephrase: If all the resources that have gone into developing the 8086 since 1970 rather had gone into developing e.g. the Symbolics CPUs, who know where we'd been.
<frodef>
s
aartaka has quit [Ping timeout: 246 seconds]
iskander has quit [Ping timeout: 264 seconds]
<dim>
remember Alan Kay said that hindsight is worth 80 points of IQ
iskander has joined #lisp
<ebrasca>
frodef: There are other instruction sets, like ppc64.
<beach>
frodef: So what are your future plans, if any, for Common Lisp hacking? Movitz2?
<ludston>
frodef: I think that Intel/AMD are going to optimize for javascript, and CL will come along for the ride
iskander- has joined #lisp
iskander has quit [Ping timeout: 246 seconds]
VincentVega has joined #lisp
housel has joined #lisp
<beach>
"Fredman"?
<frodef>
ludston: hopefully, yes.
<frodef>
beach: Not sure, something Fredman-ish hopefully.
<beach>
Great!
<frodef>
seems to me run-times are woefully underdeveloped in software engineering.
<beach>
Can you elaborate on that?
<beach>
Oh, you mean in the SE curricula?
SpaceIgor2075 has quit [Read error: Connection reset by peer]
<frodef>
beach: both in theory/school and in practice/industry.
<beach>
I can believe that.
<beach>
Does that suggest a direction of work?
<frodef>
Seems to me a bit ironic, Information Technology that isn't able to handle information about itself very well, or at all.
<beach>
There is lots of irony in the software industry.
<beach>
It has got to be one of the least efficient domains. At least I hope the others are better.
<ck_>
is that why mainframes used to be called "big iron" ?
VincentVega has left #lisp [#lisp]
<beach>
"iron"ic? Oh dear!
<frodef>
my kids would call this a "dad-joke" and give me a look.
<beach>
frodef: Are you currently employed in the software industry? If so, is your plan to transform it? Seems kind of hard, no?
<frodef>
btw. I find that quicklisp and cliki.net are great for finding and loading libraries, but is there nothing in the way of "canonical" or "preferred" lists of library code?
<ludston>
frodef: the awesome-cl github repo is pretty good
bitmapper has quit [Quit: Connection closed for inactivity]
<flip214>
hmmm, > In the trade-off between 90% convenience and 10% correctness Spinneret is on the side of convenience.
<Gnuxie[m]>
Yeah that's a very strange thing to say
<ebrasca>
Updated my page to use spinneret.
<flip214>
Gnuxie[m]: I guess that means that if you have a function bound on a keyword symbol (I've got a few, for debugging), you can't easily call it - (:h2 ) gives you a <h2>, after all.
<Gnuxie[m]>
Right ok
<flip214>
looks mostly cl-who compatible... I'll give it a try
<flip214>
beach: but wouldn't every (good) engineer warn about probable bugs in her code?
saganman has quit [Ping timeout: 246 seconds]
random-nick has joined #lisp
frodef has quit [Remote host closed the connection]
frodef has joined #lisp
cantstanya has quit [Remote host closed the connection]
cantstanya has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
<flip214>
hmmm, spinneret seems to take 2x as long as cl-who for generating a simple HTML document...
Nilby has joined #lisp
amb007 has joined #lisp
vegansbane6 has joined #lisp
<flip214>
but it does so much more (indentation, counting header levels, quoting only when needed, etc) that it's no surprise
aartaka_d has quit [Ping timeout: 272 seconds]
gzj has quit [Remote host closed the connection]
gzj has joined #lisp
totoro2021 has quit [Quit: Leaving]
ljavorsk has quit [Ping timeout: 264 seconds]
totoro2021 has joined #lisp
totoro2021 has quit [Client Quit]
totoro2021 has joined #lisp
<frodef>
but why oh why won't spinneret do the ((:tag :attr ..) ..) syntax?
gzj has quit [Remote host closed the connection]
gzj has joined #lisp
rogersm has joined #lisp
<flip214>
frodef: do you have a compelling reason to prefer that way?
gko_ has joined #lisp
liberliver has quit [Quit: liberliver]
liberliver has joined #lisp
<xificurC>
ludston the canonical python implementation is CPython, which is written in C. Python code is either read from a .py file (source code) or from a .pyc file (bytecode). The interpreter automatically tucks away the generated .pyc files for later reuse and reloads the .py files if they are newer than the .pyc files
<xificurC>
the pypy toolchain is interesting, you write in a subset of python and the toolchain generates a tracing JIT for you
liberliver has quit [Client Quit]
gzj has quit [Remote host closed the connection]
<frodef>
flip214: better indenting, I also think it's more explict and clear.
orivej has quit [Ping timeout: 272 seconds]
frgo_ has quit [Read error: Connection reset by peer]
frgo has joined #lisp
skapata has quit [Quit: Leaving]
Bike has joined #lisp
rumbler31 has quit [Read error: Connection reset by peer]
dbotton has joined #lisp
rumbler31 has joined #lisp
aartaka has joined #lisp
<mfiano>
As beach mentioned, cl-who is quite buggy, and the author no longer maintains it and is not sure how to fix some of the issues it has, and we're talking about a pretty smart guy who is well-known in the community. He also authored 'Common Lisp Recipes', a book that makes no mention of cl-who for the topic of HTML generation, for the aforementioned reason. If the author recommends other libraries over
<mfiano>
his own, it says something I would think.
<mfiano>
Source: The author himself:
<mfiano>
Hi Michael,Thanks for your feedback. I'm not maintaining CL-WHO or my otherlibraries anymore and I'm pretty sure there are better HTML generationlibraries out there nowadays (two of which I'm also mentioning in mybook). The problem you're referring to is unfortunately inherent tothe way CL-WHO is implemented and I'm not aware of an easy fix.Best regards,Edi.
<phoe>
awesome-cl should get to know that via some sorta issue then
luckless has quit [Remote host closed the connection]
rumbler31 has quit [Read error: Connection reset by peer]
<beach>
I think the crucial information that frodef was looking for is absent in awesome-cl. Perhaps in most cases it is not as clear as for CL-WHO ("don't use it..."). But people often look for relative advantages and disadvantages, like generality, run-time performance, compilation time, ease of use, active development, existing maintainer, etc.
rumbler31 has joined #lisp
<mfiano>
One thing I can say for certain after quite a few years doing web development in CL (though, admittedly, this was a few years ago), is there are about a dozen libraries fitting the purpose and they all fall flat. I think this is partially because of the mess that is the web itself, and partly because there is no concerted effort on such a library. One developer can do an 80% solution for their own
<mfiano>
use-case quite easily.
<beach>
So, ideally, a list like that should include such comparisons of similar libraries, and perhaps some absolute information when a library is fairly unique, like "embryonic", "needs work in ...", "performance could be better".
<Xach>
Sabra Crolleton has done some fantastic work for that for some domains
gko_ has quit [Ping timeout: 256 seconds]
<frodef>
Seems to me that "canonical" libraries are an important aspect of a programming language. In some important sense, libraries for common functionality is really part of the common language itself.
<beach>
frodef: Maybe, but we are far from that situation still.
<frodef>
having common libraries is important in the same sense it's important not to write your own macros for IF etc.
* frodef
just had a peek at the source for htmlgen from franz.
<ralt>
that makes me wonder, is parenscript maintained?
<ralt>
I made some extensions to it to support async/await a while ago but I'm not sure if I should contribute them back
<ralt>
it's also missing a tons of symbols (to make the symbol mangling work) of recent-ish additions (say, over the past 10 years), so that indicates to me that it's quite close to dead, but I never actually looked
<frodef>
btw. I did get a response from someone not Edi to my cl-who bug-report.
<mfiano>
ralt: It is not dead
<ralt>
ok. I'll try contributing back then.
<mfiano>
There seems to be recent activity on its issue tracker, and commits by the maintainer.
dbotton has quit [Quit: This computer has gone to sleep]
frodef has quit [Remote host closed the connection]
frodef` has joined #lisp
<xificurC>
I always browse the cliki recommended list of libraries, yet noone mentioned it here. Is it out of date?
wsinatra has joined #lisp
<xificurC>
awesome-cl is nice but as beach points out there's when there's a list of libraries you have no idea which one is recommended
dbotton has joined #lisp
galex-713 has quit [Ping timeout: 272 seconds]
orivej has joined #lisp
dbotton has quit [Quit: This computer has gone to sleep]
mmmattyx has joined #lisp
dbotton has joined #lisp
aartaka has quit [Read error: Connection reset by peer]
<flip214>
Well, as one(!) of the reasons I'm proposing CL is "speed" (as in "reduces number of required hardware boxes for given workload"), requiring twice the time to generate some HTML hurts quite a bit - that amounts to twice the hardware (compared to CL-WHO) and reduces the utility of my proposed solutions
thinkpad has quit [Ping timeout: 272 seconds]
thinkpad has joined #lisp
dbotton has quit [Quit: This computer has gone to sleep]
<beach>
To whom are you proposing Common Lisp?
galex-713 has joined #lisp
cage_ has joined #lisp
<xificurC>
is iterate usable without `use-package`ing it? From a REPL session I can't get it to work. Something like `(iter:iter (for i from 1 to 10) (collect i))` spurts a number of undefined function/variable warnings
mrios22 has quit [Ping timeout: 265 seconds]
ech has quit [Remote host closed the connection]
edgar-rft has joined #lisp
<xificurC>
this works and is very readable `(iter:iter (iter:for iter::i iter::from 1 iter::to 10) (iter:collect iter::i))`
bitmapper has joined #lisp
devon has quit [Ping timeout: 246 seconds]
<_death>
you can use import-from
elflng has quit [Read error: Connection reset by peer]
<travv0>
or `(iter:iter (iter:for i from 1 to 10) (iter:collect i))`
elflng has joined #lisp
galex-713 has quit [Ping timeout: 240 seconds]
ludston has quit [Ping timeout: 240 seconds]
<_death>
sbcl has iter::(iter (for i from 1 to 10) (collect i)) but it's unlikely that you want that
flazh has quit [Ping timeout: 272 seconds]
flazh has joined #lisp
<beach>
xificurC: There should be no particular reason to put your own variables in the ITER package.
<beach>
xificurC: And you can use a package-local nickname, like I for ITER.
sjl has joined #lisp
<beach>
xificurC: That would make it: (i:iter (i:for i i:from 1 i:to 10) (iter:collect i))
<travv0>
iterate doesn't export from and to
charles` has quit [Ping timeout: 260 seconds]
<travv0>
so just (i:iter (i:for i from 1 to 10) (i:collect i))
<beach>
Then :USE-ing it won't help.
<beach>
Oh, so it uses the names for the other keywords. Got it.
<travv0>
yep
<beach>
That's not too bad then.
<beach>
I mean, the package prefixes don't clutter the form too much.
<travv0>
i agree
Codaraxis has quit [Remote host closed the connection]
mgxm has quit [Quit: ....]
mgxm has joined #lisp
Codaraxis has joined #lisp
flazh has quit [Ping timeout: 246 seconds]
flazh has joined #lisp
nicktick has joined #lisp
Codaraxis has quit [Remote host closed the connection]
Codaraxis has joined #lisp
ech has joined #lisp
luckless has joined #lisp
mankaev has quit [Ping timeout: 272 seconds]
joast has quit [Quit: Leaving.]
saganman has joined #lisp
Codaraxis has quit [Remote host closed the connection]
Codaraxis has joined #lisp
Codaraxis has quit [Remote host closed the connection]
Codaraxis has joined #lisp
galex-713 has joined #lisp
Codaraxis has quit [Remote host closed the connection]
Codaraxis has joined #lisp
devon has joined #lisp
Codaraxis has quit [Remote host closed the connection]
Codaraxis has joined #lisp
v88m has joined #lisp
Codaraxis has quit [Remote host closed the connection]
Codaraxis has joined #lisp
waleee-cl has joined #lisp
karlosz has joined #lisp
gko_ has quit [Ping timeout: 272 seconds]
thinkpad has quit [Ping timeout: 256 seconds]
thinkpad has joined #lisp
ramus has quit [Quit: leaving]
frodef` has quit [Ping timeout: 272 seconds]
kmeow has joined #lisp
dbotton has joined #lisp
je-suis-rpg has joined #lisp
charles` has joined #lisp
judson_ has joined #lisp
je-suis-rpg has quit [Quit: WeeChat 3.0]
frgo_ has joined #lisp
orivej has quit [Ping timeout: 272 seconds]
frgo has quit [Ping timeout: 260 seconds]
hhdave has quit [Quit: hhdave]
caret has joined #lisp
Steeve has joined #lisp
nicktick has quit [Ping timeout: 260 seconds]
luckless has quit [Remote host closed the connection]
Cymew has quit [Ping timeout: 246 seconds]
luckless has joined #lisp
iamFIREcracker has quit [Read error: Connection reset by peer]
liberliver has joined #lisp
iamFIREcracker has joined #lisp
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
hlavaty has quit [Remote host closed the connection]
karlosz has quit [Quit: karlosz]
aeth has quit [Ping timeout: 256 seconds]
Jesin has joined #lisp
aeth has joined #lisp
mindCrime has quit [Ping timeout: 264 seconds]
mmmattyx has quit [Quit: Connection closed for inactivity]
Lycurgus has joined #lisp
lotuseater has quit [Remote host closed the connection]
<frodef>
slightly off-topic, but can anyone tell me when I am editing a file in emacs that is under git, how can I get a buffer with a previous revision of that file?
ech has quit [Remote host closed the connection]
saganman has quit [Quit: WeeChat 1.6]
ech has joined #lisp
aeth has quit [Ping timeout: 246 seconds]
aeth has joined #lisp
<jeosol>
you want to see the files side by side?
<jeosol>
Do you use magit?
luni has quit [Quit: Connection closed]
<frodef>
I just want to see the old revision, plainly.
<frodef>
I use just the default vc thingy, I believe.
<jeosol>
frodef: I see
<jeosol>
so it's not possible?
<frodef>
(should I use magit?)
<frodef>
hopefully it's possible, but it's not obvious enough for me to figure out...
<jeosol>
I think it's possible, I just asked if you use magit as part of your workflow
ukari has quit [Remote host closed the connection]
<jeosol>
but if you are just trying to view the diff, then magit is probably an overkill.
lotuseater has joined #lisp
ukari has joined #lisp
<frodef>
not even a diff, just the plain file version that I checked in some days ago.. seems to me the most basic of operations, but somehow it's not obvious how to do it.
aeth_ has joined #lisp
<jeosol>
frodef: you'd check it out from git commit and then view it right.
aeth has quit [Disconnected by services]
pfdietz has joined #lisp
aeth_ is now known as aeth
v88m has quit [Read error: Connection reset by peer]
v88m has joined #lisp
<frodef>
or rather, I can do M-x vc-revision-other-window, but I don't know how to name an old revision. Probably I don't understand git.
<ck_>
you can say HEAD^ for the previous, or HEAD~23 for the 23th-previous one, for example
<ck_>
"23rd" even -- how embarrassing! I'll now hide before someone "off-topic!"s me out of here
<frodef>
ck_: thanks! (I'm surprised/frustrated that I can't seem to find a menu over old revisions, though.)
<ck_>
you should try magit, it's very helpful
pfdietz has quit [Quit: Connection closed]
<frodef>
ck_: ok. I just thought I could use vc pretty much like I used to do with CVS, but I guess not.
lucasb has joined #lisp
<ck_>
you probably can, I don't have experience with that though. Many things are probably just personal preference, but it's generally accepted that magit is very polished, and its menu system is (I think) easy to pick up
thinkpad has quit [Ping timeout: 260 seconds]
karlosz has joined #lisp
thinkpad has joined #lisp
xanderle_ has quit [Ping timeout: 256 seconds]
thinkpad has quit [Ping timeout: 240 seconds]
andreyor1 is now known as andreyorst_
thinkpad has joined #lisp
andreyorst has quit [Ping timeout: 265 seconds]
luni has joined #lisp
MrFantastik is now known as technornancy
andreyorst has joined #lisp
technornancy is now known as MrFantastik
sauvin has quit [Read error: Connection reset by peer]
mmmattyx has joined #lisp
andreyorst has quit [Ping timeout: 246 seconds]
aeth_ has joined #lisp
aeth has quit [Disconnected by services]
aeth_ is now known as aeth
rumbler31_ has quit [Ping timeout: 256 seconds]
Fir3 has joined #lisp
jeosol has quit [Quit: Connection closed]
Fir3 has left #lisp [#lisp]
rumbler31_ has joined #lisp
xanderle has joined #lisp
trafaret1 has joined #lisp
bitmapper has joined #lisp
python476 has joined #lisp
Lycurgus has quit [Quit: Exeunt]
jeosol has joined #lisp
random-nick has quit [Quit: quit]
trafaret1 has quit [Remote host closed the connection]
aartaka has quit [Read error: Connection reset by peer]
aartaka_d has joined #lisp
l1x has joined #lisp
attila_lendvai has quit [Ping timeout: 256 seconds]
thinkpad has quit [Ping timeout: 256 seconds]
thinkpad has joined #lisp
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
judson_ has joined #lisp
catalinbostan has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
aartaka_d has quit [Ping timeout: 264 seconds]
karlosz_ has joined #lisp
karlosz has quit [Ping timeout: 265 seconds]
karlosz_ is now known as karlosz
orivej has joined #lisp
ukari has quit [Remote host closed the connection]